Template specialization - different behaviour between MSVC and GCC/MinGW

Question

I specialized a template and encountered a different beahviour between the MSVC compiler and MinGW/GCC. Here is the header file:

// MyClass.h
#ifndef MYCLASS_HEADER
#define MYCLASS_HEADER

template<typename T>
class MyClass {
public:
   virtual void doSomething() {
      // some code
   }
};

// specialization prototype here

#endif

Now, the difference. To avoid multiple definitions, i specialized only a prototype in the header file, the implementation is in a cpp file. The specialization is the problem. the GCC/MinGW compiler accepts only this one:

template<> void MyClass<int>::doSomething(); // GCC version

And MSVC only this:

extern template void MyClass<int>::doSomething(); // MSVC version

The implementation in the CPP file is the same for both:

// MyClass.cpp
#include "MyClass.h"

template<> void MyClass<int>::doSomething() {
   // some code
}

with the GCC prototype the MSVC compiler throws an "unresolved external symbol" error, GCC with the MSVC version throws "specialization of ... after instantiation".

At the moment, i have the workaround:

#ifdef _MSC_VER
extern template
#else
template<>
#endif
void MyClass<int>::doSomething();

in the header file. It works, but i don't like it. Is there a way to avoid the compiler specific switch?

What versions of MSVC and GCC are you using? – Gonmator Jun 19 '13 at 15:25 — Gonmator, Jun 19 '13 at 15:25

Jonathan Wakely · Accepted Answer · 2013-06-19T20:44:42.793

These are not the same thing:

template<> void MyClass<int>::doSomething(); // GCC version

extern template void MyClass<int>::doSomething(); // MSVC version

The first one declares an explicit specialization, the second one declares an explicit instantiation.

with the GCC prototype the MSVC compiler throws an "unresolved external symbol" error, GCC with the MSVC version throws "specialization of ... after instantiation".

The GCC error is telling you that there has been an implicit instantiation of MyClass<int>::doSomething() earlier in the file than the declaration of the explicit specialization; that is a bug in your code. You must declare the explicit specialization before any use of it that causes an implicit instantiation, otherwise that implicit instantiation will use the primary template definition, not the specialization. You can usually ensure that the specialization is declared before it's used by declaring it directly after the definition of the primary template, before any instantiations of MyClass<int>.

I don't know why you get the MSVC error, it sounds as though you are failing to link to MyClass.cpp. If that's not it, you could try adding an explicit instantiation definition to MyClass.cpp to force the symbol to be emitted in that file:

template void MyClass<int>::doSomething();  // N.B. no "extern" on definition

Have you tried declaring both the specialization and instantiation, but ensuring they are declared before any implicit instantiations? That should be valid C++ e.g.

#ifndef MYCLASS_H
#define MYCLASS_H
template<typename T>
class MyClass {
public:
   virtual void doSomething() {
      // some code
   }
};
// declare explicit specialization
template<> void MyClass<int>::doSomething();
// declare explicit instantiation
extern template void MyClass<int>::doSomething();
#endif

.

// MyClass.cpp
#include "MyClass.h"

// define explicit specialization
template<> void MyClass<int>::doSomething() {
   // some code
}
// define explicit instantiation
template void MyClass<int>::doSomething();

Alternatively, if you can't make that work with both compilers, you could put the definition of the specialized member function in the header and declare it inline, which would also avoid multiple definition errors.

`inline` solved the problem. now, i have the definition in the header file: `template<> inline MyClass::doSomething() { /*code*/ }` works for both compilers. thanks — WoJo, Jun 20 '13 at 08:12

TractorPulledPork · Answer 2 · 2013-06-19T15:48:41.763

0

It looks like the standard says extern is correct, might be a bug in some implementations:

Excerpt from 14.7.2 Explicit instantiation:

"The syntax for explicit instantiation is:
extern_opt template declaration

There are two forms of explicit instantiation: an explicit instantiation deﬁnition and an explicit instantiation declaration. An explicit instantiation declaration begins with the extern keyword."

edited Jun 19 '13 at 15:48

answered Jun 19 '13 at 15:43

TractorPulledPork

783
3
8

Standard also says "_An explicit specialization of any of the following [...] -member function of a class template [...] can be declared by a declaration introduced by `template<>`_". In despite of is very interesting to know what compiler works fine, that doesn't answer the question. – Gonmator Jun 19 '13 at 15:48
Then I suppose my answer is no, you're probably doing it the best way until compiler conformance increases. – TractorPulledPork Jun 19 '13 at 15:51
`extern` is correct **if you want to declare an explicit instantiation** ... it's not clear that's what the OP wants to do though – Jonathan Wakely Jun 19 '13 at 15:58

Template specialization - different behaviour between MSVC and GCC/MinGW

2 Answers2