CRTP中静态模板成员的初始化

Question

I try to initialize a static member of a CRTP base class. The base class holds a static template member of the derived class, while the derived class defines other data members. I want to statically initialize this variable. In code, a minimal example would be the following:

template<typename DERIVED>
class base {
    public:
        static DERIVED x;   
};

class derived : public base<derived>
{
    public:
        int a;   
};

int base<derived>::x {0};

int main()
{}

However, the above does not compile, but gives the error message error: specializing member 'base<derived>::x' requires 'template<>' syntax . How can I get the static initialization to work?

Answer 1

The correct syntax is:

template <class T>
class base {
  public:
    static T x;   
};

template <class T>
T base<T>::x{};

Note that you can't initialize x to a specific integer value, since then your base class won't compile when DERIVED is eg an std::string .

You probably also want your inheritance to be explicitly public or private. Ie:

class derived : public base<derived> {
  public:
    int a;   
};

Edit: To specialize x and it's initialization for specific types T , you have to specialize base itself. Ie:

class A;

template <>
class base<A> {
  public:
    static int x;   
};

// Note missing "template <>" here.
int base<A>::x{ 5 };

class A : public base<A> { };

This seems rather cumbersome, since you need to already forward declare A in this case before declaring the specialization. To me it feels you might want to rethink your design. Is this really required or is there a simpler way to accomplish what you want?

Answer 2

I have found the static initializer trick, which works in the above setting, too. It was described here and here . In the above context, it would be as follows:

#include <iostream>

template<typename DERIVED>
class base {
    public:
        static inline DERIVED x;   
};

class derived : public base<derived>
{
    public:
        int a;
        
        struct static_initializer {
            static_initializer()
            {
                derived::x.a = 1;
            }
        };
         
        static inline static_initializer static_initializer_;        
};

int main()
{
    std::cout << derived::x.a << "\n";
}

The above output the value 1 .

Note: this works with C++17.