Bdtjtk

I'm trying to make use of std::basic_stringstream<char16_t> with a UTF16-based std::numpunct. But an attempt to create even the simplest possible derivative of std::numpunct<char16_t> fails at link stage. Here's the code:

#include <locale>



struct my_punct : public std::numpunct<char16_t> {};



int main()

{

    my_punct n;

}

And here are link errors (using g++ 7.2.0) (live test):

$ g++-7 test0.cpp -o test

/tmp/cc0oWPhL.o: In function `std::numpunct<char16_t>::numpunct(unsigned int)':

test0.cpp:(.text._ZNSt8numpunctIDsEC2Ej[_ZNSt8numpunctIDsEC5Ej]+0x36): undefined reference to `std::numpunct<char16_t>::_M_initialize_numpunct(__locale_struct*)'

/tmp/cc0oWPhL.o: In function `my_punct::~my_punct()':

test0.cpp:(.text._ZN8my_punctD2Ev[_ZN8my_punctD5Ev]+0x18): undefined reference to `std::numpunct<char16_t>::~numpunct()'

/tmp/cc0oWPhL.o:(.rodata._ZTVSt8numpunctIDsE[_ZTVSt8numpunctIDsE]+0x8): undefined reference to `std::numpunct<char16_t>::~numpunct()'

/tmp/cc0oWPhL.o:(.rodata._ZTVSt8numpunctIDsE[_ZTVSt8numpunctIDsE]+0xc): undefined reference to `std::numpunct<char16_t>::~numpunct()'

collect2: error: ld returned 1 exit status

If I change char16_t to char, linking completes successfully. So, what am I doing wrong here? Do I need some additional library to link against?

As a sanity check, I've tried grepping GCC installation for _ZTVSt8numpunctIDsE, and it gave no result. But grepping for _ZTVSt8numpunctIcE did find libstdc++.so.6.0.24. Does this mean I've found a bug in libstdc++?

It's because there isn't a supporting implementation for the specialized class. What happens when you utilize a template is that the compiler generates a symbol for that particular use. If there is already a predefined and fully templated implementation, then the compiler can make its own definition, but only if it sees the templated implementation when it compiles the file trying to use it. If it can't see it, then it just creates the symbol, leaves it undefined, and expects to link it later.

As a quick example...

in Template_Add.h

// Generic template

template< class T >

T add(T first, T second);

in Template_Add.cpp

// Specialized for int

template<>

int add<int>(int first, int second){

in main.cpp

#include "Template_Add.h"



int main(){

   int     ia, ib, ic;

   double  da, db, dc;



   ia = 3;

   ib = 4;



   da = 3.0;

   db = 4.0;





   // we expect ia = 7, and works

   ic = add(ib, ic);



   // we expect dc = 7.0, but doesn't work

   // this will result in an unresolved symbol

   dc = add(da, db);



return 0;

}

The reason for this behavior is that there isn't a templated implementation that exists anywhere where main.cpp can see it. When everything is linked, however, the linker sees that an "int add(int, int)" exists, and so that is allowed.

If you own the template, then you can add the (templated) implementation into the .h file containing the template declaration. That way the compiler knows how to generate the symbol and definition at compile time. To fix our above example, we could add the following code to Template_Add.h:

template< class T >

T add(T first, T second){

   return first + second;

}

...and then anything including "Template_Add.h" would be able to generate its own implementation for anything trying to make use of the template.

If you don't own the template, then the best you can do is find a way to use the supported template specializations. In this case, it might be best to cast (or typedef) your char16_t into a short, and then see if that works.