Define `static constexpr` function on source file

Question

I have a class on a header file, which has its members defined inside a pimpl class. The idea is that I use this method (basically std::aligned_storage_t and a pointer, but the size and alignment of the class have to be specified when declaring the object) to allocate the pimpl class on the stack. I want to make the code cross-compiler so guessing isn't an option, thus I defined 2 private static constexpr functions: impl_size and impl_align which are defined on the corresponding source file and basically return sizeof(pimpl) and alignof(pimpl). The problemm is that I get the following error from MSVC (not tested on other compilers):

expression must have a constant value -- constexpr function function "Type::impl_size" (declared at line 70) is not defined

line 70 is where impl_size is defined on the header.

MCVE:

#include <cstddef>

template <typename T1, std::size_t N1, std::size_t N2>
struct Pimpl;

class Type
{
  private:
    static constexpr std::size_t impl_size() noexcept; // line 70
    static constexpr std::size_t impl_align() noexcept;

    struct impl {};

    Pimpl<impl, impl_size(), impl_align()> data; // error happens here
};

constexpr std::size_t Type::impl_size() noexcept
{
    return sizeof(Type::impl);
}

constexpr std::size_t Type::impl_align() noexcept
{
    return alignof(Type::impl);
}

Answer 1

It's what it says: you didn't define your member function when you declared it constexpr.

You must provide the definition immediately, inline in the class definition.

Answer 2

There are a couple issues with your code that strike me as odd. The point of the "PImpl" idiom is to decouple an interface from its implementation, typically in order to allow easier compilation when the implementation changes. However, by defining your struct impl inside your interface class and by using it in a template within the same class, you are essentially forcing the implementation to be coupled with with the interface.

sizeof and alignof require a complete type, which impl does not appear to be(EDIT at the time of writing, impl was simply forward-declared), and so even after fixing the issues with Type::impl_size() and Type::impl_align(), you'll encounter this problem.

An immediate and somewhat shallow fix to your problem would be to make impl a complete type (and define it at the point of declaration), and to make impl_size() and impl_align() into inline static constexpr functions that are also defined on the spot:

class type
{
  // ...

  private:
    struct impl {
        // struct definition, so that impl is a complete type
    };

    inline static constexpr impl_size() noexcept {
        return sizeof(impl);
    }
    inline static constexpr impl_align() noexcept {
        return alignof(impl);
    }
    
    Pimpl<impl, impl_size(), impl_align()> data;
};

This still smells a bit because impl_size and impl_align are pointless boilerplate, and your PImpl template can have all the same information directly from its first parameter:

template<typename T>
class Pimpl {
    static constexpr std::size_t Size = sizeof(T);
    static constexpr std::size_t Alignment = alignof(T);
};

class type {
  private:
    struct impl {};
    
    Pimpl<impl> data;
};

This of course also requires impl to be a complete type. And this will be required anyway if struct impl is a nested cless.

It appears you're trying to do some kind of type-erasure here (or is there another good reason you need the size and alignment of impl?), but have inadvertently introduced a lot of dependencies on the implementation and types involved.

I would suggest the following: forward-declare your impl class at namespace scope, and simply use a std::unique_ptr<impl> for your implementation. Then impl can be defined in your implementation file. Note that std::unique_ptr does not require a complete type.

#include <iostream>
#include <memory>

// header.hpp
struct impl;

class type {
public:
    type();
    void doThing();
    
private:
    std::unique_ptr<impl> m_pImpl;
};

// source.cpp
struct impl {
    void doThingImpl() {
        std::cout << "Did a thing";
    }
};

type::type()
    : m_pImpl(std::make_unique<impl>()) {
      
}

void type::doThing() {
    m_pImpl->doThingImpl();
}

int main(){
    auto t = type{};
    t.doThing();
    
    return 0;
}

Live Demo