Question

I’ve got some code that compiles fine under MSVC (or so say the Windows developers who sent me it), but gives an error under CLang. Having looked around I’ve found that CLang is indeed more strict about resolving template specializations, but I’m not sure where I should put the specializations in my case. Basically one of my files has a struct like this:

template<>
struct iterator_traits< char * >   // error is here
{
    typedef random_access_iterator_tag iterator_category;
    typedef char value_type;
    typedef ptrdiff_t difference_type;
    typedef difference_type distance_type;
    typedef char * pointer;
    typedef char & reference;
};

This is within a namespace std block. The error message is:

Explicit specialization of 'std::iterator_traits<char *>' after instantiation

Another part of the same error message (viewed by ‘expanding’ the error message in Xcode) says Implicit instantiation first required here, and clicking on that takes me to stl_iterator.h, specifically this line (line 642):

typedef typename iterator_traits<_Iterator>::iterator_category
                                                         iterator_category;

Does anyone know what the correct thing to do would be in this case? I’ve seen examples involving classes but never one involving a struct.

Answer 1

The compiler is complaining that you’re trying to specialize a template after instantiating the generic template — by that point in time, the compiler has already used the generic template for the instantiation, and it can’t go back and use your specialization instead. In other words, something like this:

template <typename T>
struct X
{
    // Generic implementation
};

// Instantiate template by using it in any way
X<int> foo;

template<>
struct X<int>
{
    // Specialization implementation for int
};

The fix is to define the specialization before it’s instantiated, so in this example, you’d move the X<int> specialization to before where X<int> is used.

Note that the STL already defines specializations of std::iterator_trait for pointer types, so there’s no need to define your own specialization here for char*. You’d typically only do that for user-defined iterator types which are not pointers. See §24.3.1/2 of the C++03 standard:

[The template iterator_traits<Iterator>] is specialized for pointers as

template<class T> struct iterator_traits<T*> {
  typedef ptrdiff_t difference_type;
  typedef T value_type;
  typedef T* pointer;
  typedef T& reference;
  typedef random_access_iterator_tag iterator_category;
};

and for pointers to const as

template<class T> struct iterator_traits<const T*> {
  typedef ptrdiff_t difference_type;
  typedef T value_type;
  typedef const T* pointer;
  typedef const T& reference;
  typedef random_access_iterator_tag iterator_category;
};

So there’s no point to providing your own std::iterator_traits<char*> specialization. Since char* is not a user-defined type, it’s also undefined behavior according to the standard. §17.4.3.1/1 says:

It is undefined for a C + + program to add declarations or definitions to namespace std or namespaces
within namespace std unless otherwise specified. A program may add template specializations for any
standard library template to namespace std. Such a specialization (complete or partial) of a standard
library template results in undefined behavior unless the declaration depends on a user-defined name of
external linkage and unless the specialization meets the standard library requirements for the original template.¹⁶³⁾

163) Any library code that instantiates other library templates must be prepared to work adequately with any user-supplied specialization
that meets the minimum requirements of the Standard