Storing C template function definitions in a CPP file

Question

I have some template code that I would prefer to have stored in a CPP file instead of inline in the header   I know this can be done as long as you know which template types will be used   For example    h file  class foo   public      template  lt typename T gt      void do const T amp  t         cpp file  template  lt typename T gt  void foo  do const T amp  t           Do something with t    template void foo  do lt int gt  const int amp    template void foo  do lt std  string gt  const std  string amp      Note the last two lines - the foo  do template function is only used with ints and std  strings  so those definitions mean the app will link   My question is - is this a nasty hack or will this work with other compilers linkers  I am only using this code with VS2008 at the moment but will be wanting to port to other environments

User · Answer

That is a standard way to define template functions. I think there are three methods I read for defining templates. Or probably 4. Each with pros and cons.

Define in class definition. I don't like this at all because I think class definitions are strictly for reference and should be easy to read. However it is much less tricky to define templates in class than outside. And not all template declarations are on the same level of complexity. This method also makes the template a true template.
Define the template in the same header, but outside of the class. This is my preferred way most of the times. It keeps your class definition tidy, the template remains a true template. It however requires full template naming which can be tricky. Also, your code is available to all. But if you need your code to be inline this is the only way. You can also accomplish this by creating a .INL file at the end of your class definitions.
Include the header.h and implementation.CPP into your main.CPP. I think that's how its done. You won't have to prepare any pre instantiations, it will behave like a true template. The problem I have with it is that it is not natural. We don't normally include and expect to include source files. I guess since you included the source file, the template functions can be inlined.
This last method, which was the posted way, is defining the templates in a source file, just like number 3; but instead of including the source file, we pre instantiate the templates to ones we will need. I have no problem with this method and it comes in handy sometimes. We have one big code, it cannot benefit from being inlined so just put it in a CPP file. And if we know common instantiations and we can predefine them. This saves us from writing basically the same thing 5, 10 times. This method has the benefit of keeping our code proprietary. But I don't recommend putting tiny, regularly used functions in CPP files. As this will reduce the performance of your library.

Note, I am not aware of the consequences of a bloated obj file.

User · Answer

There is nothing wrong with the example you have given  But i must say i believe it s not efficient to store function definitions in a cpp file  I only understand the need to separate the function s declaration and definition   When used together with explicit class instantiation  the Boost Concept Check Library  BCCL  can help you generate template function code in cpp files

User · Answer

There is nothing wrong with the example you have given  But i must say i believe it s not efficient to store function definitions in a cpp file  I only understand the need to separate the function s declaration and definition   When used together with explicit class instantiation  the Boost Concept Check Library  BCCL  can help you generate template function code in cpp files

User · Answer

Let s take one example  let s say for some reason you want to have a template class     test template h   pragma once  include  lt cstdio gt   template  lt class T gt  class DemoT   public      void test                 printf  ok n              template  lt  gt  void DemoT lt int gt   test         printf  int test  int  n        template  lt  gt  void DemoT lt bool gt   test         printf  int test  bool  n        If you compile this code with Visual Studio - it works out of box  gcc will produce linker error  if same header file is used from multiple  cpp files    error   multiple definition of  DemoT lt int gt   test     your o      test template h 16  first defined here   It s possible to move implementation to  cpp file  but then you need to declare class like this -     test template h   pragma once  include  lt cstdio gt   template  lt class T gt  class DemoT   public      void test                 printf  ok n              template  lt  gt  void DemoT lt int gt   test     template  lt  gt  void DemoT lt bool gt   test        Instantiate parametrized template classes  implementation resides on  cpp side  template class DemoT lt bool gt   template class DemoT lt int gt     And then  cpp will look like this     test template cpp   include  test template h   template  lt  gt  void DemoT lt int gt   test         printf  int test  int  n        template  lt  gt  void DemoT lt bool gt   test         printf  int test  bool  n        Without two last lines in header file - gcc will work fine  but Visual studio will produce an error    error LNK2019  unresolved external symbol  public  void   cdecl DemoT lt int gt   test void     test   DemoT H  QEAAXXZ  referenced in function   template class syntax is optional in case if you want to expose function via  dll export  but this is applicable only for windows platform - so test template h could look like this     test template h   pragma once  include  lt cstdio gt   template  lt class T gt  class DemoT   public      void test                 printf  ok n               ifdef  WIN32      define DLL EXPORT   declspec dllexport    else      define DLL EXPORT  endif  template  lt  gt  void DLL EXPORT DemoT lt int gt   test     template  lt  gt  void DLL EXPORT DemoT lt bool gt   test      with  cpp file from previous example   This however gives more headache to linker  so it s recommended to use previous example if you don t export  dll function

User · Answer

Yes  that s the standard way to do specializiation explicit instantiation   As you stated  you cannot instantiate this template with other types   Edit  corrected based on comment

User · Answer

This code is well-formed  You only have to pay attention that the definition of the template is visible at the point of instantiation  To quote the standard     14 7 2 4      The definition of a non-exported function template  a non-exported member function template  or a non-exported member function or static data member of a class template shall be present in every translation unit in which it is explicitly instantiated

User · Answer

Time for an update  Create an inline   inl  or probably any other  file and simply copy all your definitions in it  Be sure to add the template above each function  template  lt typename T      gt    Now instead of including the header file in the inline file you do the opposite  Include the inline file after the declaration of your class   include  file inl     I don t really know why no one has mentioned this  I see no immediate drawbacks

User · Answer

None of above worked for me  so here is how y solved it  my class have only 1 method templated     h  class Model       template  lt class T gt      void build T  b  uint32 t number         cpp   include  Model h  template  lt class T gt  void Model  build T  b  uint32 t number          implementation    void TemporaryFunction         Model m      m build lt B1 gt  new B1   1       m build lt B2 gt  new B2    1       m build lt B3 gt  new B3    1       this avoid linker errors  and no need to call TemporaryFunction at all

User · Answer

Your example is correct but not very portable  There is also a slightly cleaner syntax that can be used  as pointed out by  namespace-sid  among others   However  suppose the templated class is part of some library that is to be shared    Should other versions of the templated class be compiled  Is the library maintainer supposed to anticipate all possible templated uses of the class  An Alternate Approach Add a third file that is the template implementation instantiation file in your sources  lib foo hpp in from library  pragma once  template  lt typename T gt  class foo   public      void bar const T amp        lib foo cpp compiling this file directly just wastes compilation time    Include guard here  just in case  pragma once   include  quot foo hpp quot   template  lt typename T gt  void foo  bar const T amp  arg           Do something with  arg     foo MyType cpp using the library  explicit template instantiation of foo lt MyType gt     Consider adding  quot anti-guard quot  to make sure it s not included in other translation units  if   INCLUDE LEVEL      0    error  quot Don t include this file quot   endif     Yes  we include the  cpp file  include  lt lib foo cpp gt   include  quot MyType hpp quot   template class foo lt MyType gt    Of course  you can have multiple implementations in the third file  Or you might want multiple implementation files  one for each type  or set of types  you d like to use  for instance  This setup should reduce compile times  especially for heavily used complicated templated code  because you re not recompiling the same header file in each translation unit  It also enables better detection of which code needs to be recompiled  by compilers and build scripts  reducing incremental build burden  Usage Examples foo declarations hpp needs to know about foo lt MyType gt  s public interface but not  cpp sources  pragma once   include  lt lib foo hpp gt   include  quot MyType hpp quot      Declare  temp   Doesn t need to include  foo cpp  extern foo lt MyType gt  temp   examples cpp can reference local declaration but also doesn t recompile foo lt MyType gt   include  quot foo declarations hpp quot   MyType instance      Define  temp   Doesn t need to include  foo cpp  foo lt MyType gt  temp   void example 1            Use  temp      temp bar instance      void example 2            Function local instance     foo lt MyType gt  temp2          Use templated library function     temp2 bar instance      error cpp example that would work with pure header templates but doesn t here  include  lt lib foo hpp gt      Causes compilation errors at link time since we never had the explicit instantiation     template class foo lt int gt      GCC linker gives an error   quot undefined reference to  foo lt int gt   bar    quot   void linkerError         foo lt int gt  nonExplicitlyInstantiatedTemplate     Note that most compilers linters code helpers won t detect this as an error  since there is no error according to C   standard  But when you go to link this translation unit into a complete executable  the linker won t find a defined version of foo lt int gt

User · Answer

There is  in the latest standard  a keyword  export  that would help alleviate this issue  but it isn t implemented in any compiler that I m aware of  other than Comeau   See the FAQ-lite about this

User · Answer

The problem you describe can be solved by defining the template in the header  or via the approach you describe above   I recommend reading the following points from the C   FAQ Lite     Why can   t I separate the definition of my templates class from its declaration and put it inside a  cpp file  How can I avoid linker errors with my template functions  How does the C   keyword export help with template linker errors    They go into a lot of detail about these  and other  template issues

User · Answer

This should work fine everywhere templates are supported  Explicit template instantiation is part of the C   standard

User · Answer

This is definitely not a nasty hack  but be aware of the fact that you will have to do it  the explicit template specialization  for every class type you want to use with the given template  In case of MANY types requesting template instantiation there can be A LOT of lines in your  cpp file  To remedy this problem you can have a TemplateClassInst cpp in every project you use so that you have greater control what types will be instantiated  Obviously this solution will not be perfect  aka silver bullet  as you might end up breaking the ODR

User · Answer

For others on this page wondering what the correct syntax is  as did I  for explicit template specialisation  or at least in VS2008   its the following     In your  h file     template lt typename T gt  class foo   public      void bar const T  amp t        And in your  cpp file  template  lt class T gt  void foo lt T gt   bar const T  amp t          Explicit template instantiation template class foo lt int gt

[c++] Storing C++ template function definitions in a .CPP file

Examples related to c++

Examples related to templates