Splitting templated C classes into hpp cpp files--is it possible

Question

I am getting errors trying to compile a C   template class which is split between a  hpp and  cpp file     g   -c -o main o main cpp     g   -c -o stack o stack cpp      g   -o main main o stack o   main o  In function  main     main cpp   text 0xe   undefined reference to  stack lt int gt   stack      main cpp   text 0x1c   undefined reference to  stack lt int gt    stack      collect2  ld returned 1 exit status   make       program  Error 1     Here is my code   stack hpp    ifndef  STACK HPP  define  STACK HPP  template  lt typename Type gt  class stack       public              stack                 stack        endif   stack cpp    include  lt iostream gt   include  stack hpp   template  lt typename Type gt  stack lt Type gt   stack             std  cerr  lt  lt   Hello  stack    lt  lt  this  lt  lt       lt  lt  std  endl     template  lt typename Type gt  stack lt Type gt    stack             std  cerr  lt  lt   Goodbye  stack    lt  lt  this  lt  lt       lt  lt  std  endl      main cpp    include  stack hpp   int main         stack lt int gt  s       return 0      ld is of course correct  the symbols aren t in stack o   The answer to this question does not help  as I m already doing as it says  This one might help  but I don t want to move every single method into the  hpp file mdash I shouldn t have to  should I   Is the only reasonable solution to move everything in the  cpp file to the  hpp file  and simply include everything  rather than link in as a standalone object file  That seems awfully ugly  In that case  I might as well revert to my previous state and rename stack cpp to stack hpp and be done with it

User · Answer

Only if you  include  stack cpp at the end of stack hpp  I d only recommend this approach if the implementation is relatively large  and if you rename the  cpp file to another extension  as to differentiate it from regular code

User · Answer

The problem is that a template doesn t generate an actual class  it s just a template telling the compiler how to generate a class  You need to generate a concrete class   The easy and natural way is to put the methods in the header file  But there is another way   In your  cpp file  if you have a reference to every template instantiation and method you require  the compiler will generate them there for use throughout your project   new stack cpp    include  lt iostream gt   include  stack hpp  template  lt typename Type gt  stack lt Type gt   stack             std  cerr  lt  lt   Hello  stack    lt  lt  this  lt  lt       lt  lt  std  endl    template  lt typename Type gt  stack lt Type gt    stack             std  cerr  lt  lt   Goodbye  stack    lt  lt  this  lt  lt       lt  lt  std  endl    static void DummyFunc         static stack lt int gt  stack int      generates the constructor and destructor code            any other method invocations need to go here to produce the method code

User · Answer

It is not possible to write the implementation of a template class in a separate cpp file and compile  All the ways to do so  if anyone claims  are workarounds to mimic the usage of separate cpp file but practically if you intend to write a template class library and distribute it with header and lib files to hide the implementation  it is simply not possible    To know why  let us look at the compilation process  The header files are never compiled  They are only preprocessed  The preprocessed code is then clubbed with the cpp file which is actually compiled  Now if the compiler has to generate the appropriate memory layout for the object it needs to know the data type of the template class    Actually it must be understood that template class is not a class at all but a template for a class the declaration and definition of which is generated by the compiler at compile time after getting the information of the data type from the argument  As long as the memory layout cannot be created  the instructions for the method definition cannot be generated  Remember the first argument of the class method is the  this  operator  All class methods are converted into individual methods with name mangling and the first parameter as the object which it operates on  The  this  argument is which actually tells about size of the object which incase of template class is unavailable for the compiler unless the user instantiates the object with a valid type argument  In this case if you put the method definitions in a separate cpp file and try to compile it the object file itself will not be generated with the class information  The compilation will not fail  it would generate the object file but it won t generate any code for the template class in the object file  This is the reason why the linker is unable to find the symbols in the object files and the build fails    Now what is the alternative to hide important implementation details  As we all know the main objective behind separating interface from implementation is hiding implementation details in binary form  This is where you must separate the data structures and algorithms  Your template classes must represent only data structures not the algorithms  This enables you to hide more valuable implementation details in separate non-templatized class libraries  the classes inside which would work on the template classes or just use them to hold data  The template class would actually contain less code to assign  get and set data  Rest of the work would be done by the algorithm classes    I hope this discussion would be helpful

User · Answer

I believe there are two main reasons for trying to seperate templated code into a header and a cpp   One is for mere elegance  We all like to write code that is wasy to read  manage and is reusable later   Other is reduction of compilation times   I am currently  as always  coding simulation software in conjuction with OpenCL and we like to keep code so it can be run using float  cl float  or double  cl double  types as needed depending on HW capability  Right now this is done using a  define REAL at the beginning of the code  but this is not very elegant  Changing desired precision requires recompiling the application  Since there are no real run-time types  we have to live with this for the time being  Luckily OpenCL kernels are compiled runtime  and a simple sizeof REAL  allows us to alter the kernel code runtime accordingly   The much bigger problem is that even though the application is modular  when developing auxiliary classes  such as those that pre-calculate simulation constants  also have to be templated  These classes all appear at least once on the top of the class dependency tree  as the final template  class Simulation will have an instance of one of these factory classes  meaning that practically every time I make a minor change to the factory class  the entire software has to be rebuilt  This is very annoying  but I cannot seem to find a better solution

User · Answer

You need to have everything in the hpp file   The problem is that the classes aren t actually created until the compiler sees that they re needed by some OTHER cpp file - so it has to have all the code available to compile the templated class at that time   One thing that I tend to do is to try to split my templates into a generic non-templated part  which can be split between cpp hpp  and the type-specific template part which inherits the non-templated class

User · Answer

It is possible  as long as you know what instantiations you are going to need   Add the following code at the end of stack cpp and it ll work    template class stack lt int gt     All non-template methods of stack will be instantiated  and linking step will work fine

User · Answer

No  it s not possible   Not without the export keyword  which for all intents and purposes doesn t really exist     The best you can do is put your function implementations in a   tcc  or   tpp  file  and  include the  tcc file at the end of your  hpp file   However this is merely cosmetic  it s still the same as implementing everything in header files   This is simply the price you pay for using templates

User · Answer

You can do it in this way     xyz h  ifndef  XYZ   define  XYZ   template  lt typename XYZTYPE gt  class XYZ       Class members declaration      include  xyz cpp   endif    xyz cpp  ifdef  XYZ    Class definition goes here   endif   This has been discussed in Daniweb  Also in FAQ but using C   export keyword

User · Answer

1  Remember the main reason to separate  h and  cpp files is to hide the class   implementation as a separately-compiled Obj code that can be linked to the user   s code that included a  h of the class   2  Non-template classes have all variables concretely and specifically defined in  h and  cpp files  So the compiler will have the need information about all data types used in the class before compiling translating   generating the object machine code Template classes have no information about the specific data type before the user of the class instantiate an object passing the required data type            TClass lt int gt  myObj    3  Only after this instantiation  the complier generate the specific version of the template class to match the passed data type s    4  Therefore   cpp Can NOT be compiled separately without knowing the users specific data type  So it has to stay as source code within     h    until the user specify the required data type then  it can be generated to a specific data type then compiled

User · Answer

I am working with Visual studio 2010  if you would like to split your files to  h and  cpp  include your cpp header at the end of the  h file

User · Answer

If you know what types your stack will be used with  you can instantiate them expicitly in the cpp file  and keep all relevant code there   It is also possible to export these across DLLs     but it s pretty tricky to get the syntax right  MS-specific combinations of   declspec dllexport  and the export keyword    We ve used that in a math geom lib that templated double float  but had quite a lot of code    I googled around for it at the time  don t have that code today though

User · Answer

The  export  keyword is the way to separate out template implementation from template declaration  This was introduced in C   standard without an existing implementation  In due course only a couple of compilers actually implemented it  Read in depth information at Inform IT article on export

User · Answer

Sometimes it is possible to have most of implementation hidden in cpp file  if you can extract common functionality foo all template parameters into non-template class  possibly type-unsafe   Then header will contain redirection calls to that class  Similar approach is used  when fighting with  template bloat  problem

User · Answer

The place where you might want to do this is when you create a library and header combination  and hide the implementation to the user  Therefore  the suggested approach is to use explicit instantiation  because you know what your software is expected to deliver  and you can hide the implementations  Some useful information is here  https   docs microsoft com en-us cpp cpp explicit-instantiation view vs-2019 For your same example  Stack hpp template  lt class T gt  class Stack    public      Stack         Stack        void Push T val       T Pop    private      T val       template class Stack lt int gt    stack cpp  include  lt iostream gt   include  quot Stack hpp quot  using namespace std   template lt class T gt  void Stack lt T gt   Push T val        cout  lt  lt   quot Pushing Value  quot   lt  lt  endl      this- gt val   val     template lt class T gt  T Stack lt T gt   Pop         cout  lt  lt   quot Popping Value  quot   lt  lt  endl      return this- gt val     template  lt class T gt  Stack lt T gt   Stack         cout  lt  lt   quot Construct Stack  quot   lt  lt  this  lt  lt  endl     template  lt class T gt  Stack lt T gt    Stack         cout  lt  lt   quot Destruct Stack  quot   lt  lt  this  lt  lt  endl     main cpp  include  lt iostream gt  using namespace std    include  quot Stack hpp quot   int main         Stack lt int gt  s      s Push 10       cout  lt  lt  s Pop    lt  lt  endl      return 0     Output   gt  Construct Stack 000000AAC012F8B4  gt  Pushing Value  gt  Popping Value  gt  10  gt  Destruct Stack 000000AAC012F8B4  I however don t entirely like this approach  because this allows the application to shoot itself in the foot  by passing incorrect datatypes to the templated class  For instance  in the main function  you can pass other types that can be implicitly converted to int like s Push 1 2   and that is just bad in my opinion

User · Answer

Because templates are compiled when required  this forces a restriction for multi-file projects  the implementation  definition  of a template class or function must be in the same file as its declaration  That means that we cannot separate the interface in a separate header file  and that we must include both interface and implementation in any file that uses the templates

User · Answer

Another possibility is to do something like    ifndef  STACK HPP  define  STACK HPP  template  lt typename Type gt  class stack       public              stack                 stack         include  stack cpp      Note the include   The inclusion                          of stack h in stack cpp must be                           removed to avoid a circular include    endif   I dislike this suggestion as a matter of style  but it may suit you

[c++] Splitting templated C++ classes into .hpp/.cpp files--is it possible?

Examples related to c++

Examples related to class

Examples related to templates

Examples related to header

Examples related to linker