static member initialization for specialized template class

by

For static member specializations, if you don’t initialize the member, it is taken as a specialization declaration, that just says “Oh, don’t instantiate the member from the primary template, because there is a specialized definition somewhere else”. It should be mentioned that the definition should appear in a .cpp file (otherwise, you will earn the opposite: multiple definitions), and the declaration without initializer should still be placed in the header file.

Now the correct syntax is indeed the following, and it should not appear in a header file, but in a .cpp file

template<> int B<A, 1>::a[1] = { };

The following should still appear in a header file:

template<> int B<A, 1>::a[1];

This will serve as the specialization declaration.

From this, it follows that you can’t specialize a member that only has a default constructor and is not copyable, because you would need this syntax:

// needs a copy constructor!
template<> Type Class<Arguments>::member = Type();

C++0x fixes this:

// doesn't anymore need a copy constructor
template<> Type Class<Arguments>::member{};

For the Standardese people among us, here are the quotes:

14.7.3/6:

If a template, a member template or the member of a class template is explicitly specialized then that specialization shall be declared before the first use of that specialization that would cause an implicit instantiation to take place, in every translation unit in which such a use occurs; no diagnostic is required.

14.7.3/15:

An explicit specialization of a static data member of a template is a definition if the declaration includes an initializer; otherwise, it is a declaration. [Note: there is no syntax for the definition of a static data member of a template that requires default initialization. 

template<> X Q<int>::x;

This is a declaration regardless of whether X can be default initialized (8.5). ]

3.2/3:

Every program shall contain exactly one definition of every non-inline function or object that is used in that program; no diagnostic required.

3.2/5:

There can be more than one definition of a class type (clause 9), enumeration type (7.2), inline function with external linkage (7.1.2), class template (clause 14), non-static function template (14.5.5), static data member of a class template (14.5.1.3), member function of a class template (14.5.1.1), or template specialization for which some template parameters are not specified (14.7, 14.5.4) in a program […]

The restriction of this to “for which some template parameters are not specified” means that we are allowed to do the following, placing it into a header (thus possibly having multiple definitions of this specialization):

template<> template<typename T>
Type OuterClass<int>::InnerClass<T>::StaticMember = 0;

In your case, you have all parameters specified, making it not being covered by the one defintion rule for allowing multiple definitions.

More Related Contents:

  1. C++ cannot initialize static data member [duplicate]
  2. How to emulate C array initialization “int arr[] = { e1, e2, e3, … }” behaviour with std::array?
  3. Initialize static variables in C++ class?
  4. When are static C++ class members initialized?
  5. Static member initialization in a class template
  6. explicit specialization of template class member function
  7. Template specialization of particular members?
  8. c++ template partial specialization member function [duplicate]
  9. C++ Static member initialization (template fun inside)
  10. Selecting a member function using different enable_if conditions
  11. How to initialize std::array elegantly if T is not default constructible?
  12. When are static and global variables initialized?
  13. Are function static variables thread-safe in GCC?
  14. C++ where to initialize static const
  15. Template static variable
  16. Template specialization of a single method from a templated class
  17. C++ static template member, one instance for each template type?
  18. How is static variable initialization implemented by the compiler?
  19. Default template parameter partial specialization
  20. Specializing function template for reference types
  21. Specializing a template on a lambda in C++0x
  22. Default template argument and partial specialization
  23. friend declaration declares a non-template function [duplicate]
  24. Template specialization based on inherit class
  25. Does C++ support compile-time counters?
  26. C++ invoke explicit template constructor
  27. Object creation on the stack/heap?
  28. How to achieve “virtual template function” in C++
  29. Populate An Array Using Constexpr at Compile-time
  30. How to typedef a template class? [duplicate]

Leave a Comment