C templates cpp files

Raymii.org

C++ template definitions in a .cpp file (instead of a header file)

❗ This post is over four years old. It may no longer be up to date. Opinions may have changed.

Table of Contents

In this snippet I’ll show you how to place your C++ template definitions in a seperate .cpp file. I’d recommend you to just put template definitions in your header file, or a .hpp file, but if you really want to there is a trick to get them in a seperate .cpp file. The trick is to explicitly instanciate every template you’re going to use at the end of the .cpp file. With many different templates and types this becomes cumbersome, but for certain usecases it could be useful.

Recently I removed all Google Ads from this site due to their invasive tracking, as well as Google Analytics. Please, if you found this content useful, consider a small donation using any of the options below:

Template definitions

Small recap on templates. A template is not an actual class or function, but a «pattern» that the compiler uses to generate a family of classes or functions.

In order for the compiler to generate the code, it must see both the template definition (not just declaration) and the specific types/whatever used to «fill in» the template. For example, if you’re trying to use a Foo , the compiler must see both the Foo template and the fact that you’re trying to make a specific Foo . See here for more explanation.

Placing templates in your .h files might result in cluttered header files, it also could increase code bloat and the compiled binary size. (That however does depend on how smart your compiler is). For the cluttering people often resort to .hpp files. Which brings its own set of problems, for example with your build system if you’re doing something special.

The trick I found here is that you can place your template definitions in a seperate .cpp file and explicitly instanciate every form of that template that is going to be used in that .cpp file.

If you don’t instanciate all forms in your .cpp file you will get undefined reference errors, I’ll show you an example later on.

The linker however does spew out the specific form so you can copy/paste it quickly.

Example code

I’ve written a sample program with a class with one template function, one other class and the main.cpp file. This is the directory layout, you can ignore the CMake files:

$ tree -L 1 . |-- CMakeLists.txt |-- TestClass1.cpp |-- TestClass1.h |-- TestClass2.cpp |-- TestClass2.h |-- cmake-build-debug `-- main.cpp 1 directory, 6 files 

TestClass1.h

This file contains the class with one template function. It does not contain the template defintion, only the declaration. Normally you would define the entire template here but that’s the part we don’t want to in this example.

#ifndef TESTCLASS1_H #define TESTCLASS1_H #include class TestClass < private: bool m_bool1 < false >; public: TestClass(bool bool1) : m_bool1(bool1) <> // just the template declaration template void templateFunction(T1 var1, T2 var2); >; #endif //TESTCLASS1_H 

TestClass1.cpp

This is where the template is defined, and at the bottom, instanciated explicitly for the types we’re going to use in the code.

#include #include "TestClass1.h" //actual template definiton template void TestClass::templateFunction (T1 var1, T2 var2) < std::cout // Here is the explicit instanciation template void TestClass::templateFunction(int, int); template void TestClass::templateFunction(char const*, char const*); 

TestClass2.h

This is just another class where the template is used, as an example.

#ifndef TESTCLASS2_H #define TESTCLASS2_H #include "TestClass1.h" class TestClass2 < private: bool m_abc1 ; public: void printTest(); >; #endif //TESTCLASS2_H 

TestClass2.cpp

Here is the definition of the above function, where the other template is called with a const char * .

#include "TestClass2.h" void TestClass2::printTest () < TestClass example(false); example.templateFunction ("abc", "def"); >; 

main.cpp

It all comes together in the main.cpp file, one of both classes. I've used two different methods of calling the class templated function, either explicitly telling which types were using or just letting the compiler figure it out.

#include #include "TestClass1.h" #include "TestClass2.h" int main () < TestClass example1(true); example1.templateFunction(1, 2); example1.templateFunction (3, 4); TestClass2 lala = TestClass2(); lala.printTest (); return 0; > 

var1: 1, var2: 2, m_bool1: 1 var1: 3, var2: 4, m_bool1: 1 var1: abc, var2: def, m_bool1: 0 

Error, undefined reference

The warning when you forget to instanciate a template, or in this example, uncommented one:

//template void TestClass::templateFunction(int, int); template void TestClass::templateFunction(char const*, char const*); 

[100%] Linking CXX executable example CMakeFiles/folder.dir/main.cpp.o: In function `main': folder/main.cpp:7: undefined reference to `void TestClass::templateFunction(int, int)' folder/main.cpp:8: undefined reference to `void TestClass::templateFunction(int, int)' collect2: error: ld returned 1 exit status 

If you would use the template with two doubles you would have to add this at the end of the file TestClass1.cpp :

template void TestClass::templateFunction(double, double); 

In the header file

If the template function for TestClass1 was in the header file, it would look like this:

#ifndef TESTCLASS1_H #define TESTCLASS1_H #include class TestClass < private: bool m_bool1 < false >; public: TestClass(bool bool1) : m_bool1(bool1) <> // template declaration and definiton template void templateFunction (T1 var1, T2 var2) < std::cout >; #endif //TESTCLASS1_H 

You would not need the TestClass1.cpp file.

Источник

Source code organization (C++ Templates)

When defining a class template, you must organize the source code in such a way that the member definitions are visible to the compiler when it needs them. You have the choice of using the inclusion model or the explicit instantiation model. In the inclusion model, you include the member definitions in every file that uses a template. This approach is simplest and provides maximum flexibility in terms of what concrete types can be used with your template. Its disadvantage is that it can increase compilation times. The times can be significant if a project or the included files themselves are large. With the explicit instantiation approach, the template itself instantiates concrete classes or class members for specific types. This approach can speed up compilation times, but it limits usage to only those classes that the template implementer has enabled ahead of time. In general, we recommend that you use the inclusion model unless the compilation times become a problem.

Background

Templates aren't like ordinary classes in the sense that the compiler doesn't generate object code for a template or any of its members. There's nothing to generate until the template is instantiated with concrete types. When the compiler encounters a template instantiation such as MyClass mc; and no class with that signature exists yet, it generates a new class. It also attempts to generate code for any member functions that are used. If those definitions are in a file that isn't #included, directly or indirectly, in the .cpp file that is being compiled, the compiler can't see them. From the compiler's point of view, it's not necessarily an error. The functions may be defined in another translation unit where the linker will find them. If the linker doesn't find that code, it raises an unresolved external error.

The inclusion model

The simplest and most common way to make template definitions visible throughout a translation unit, is to put the definitions in the header file itself. Any .cpp file that uses the template simply has to #include the header. This approach is used in the Standard Library.

#ifndef MYARRAY #define MYARRAY #include template class MyArray < T arr[N]; public: // Full definitions: MyArray()<>void Print() < for (const auto v : arr) < std::cout > T& operator[](int i) < return arr[i]; >>; #endif 

With this approach, the compiler has access to the complete template definition and can instantiate templates on-demand for any type. It's simple and relatively easy to maintain. However, the inclusion model does have a cost in terms of compilation times. This cost can be significant in large programs, especially if the template header itself #includes other headers. Every .cpp file that #includes the header will get its own copy of the function templates and all the definitions. The linker will generally be able to sort things out so that you don't end up with multiple definitions for a function, but it takes time to do this work. In smaller programs that extra compilation time is probably not significant.

The explicit instantiation model

If the inclusion model isn't viable for your project, and you know definitively the set of types that will be used to instantiate a template, then you can separate out the template code into an .h and .cpp file, and in the .cpp file explicitly instantiate the templates. This approach generates object code that the compiler will see when it encounters user instantiations.

You create an explicit instantiation by using the keyword template followed by the signature of the entity you want to instantiate. This entity can be a type or a member. If you explicitly instantiate a type, all members are instantiated.

The header file MyArray.h declares template class MyArray :

//MyArray.h #ifndef MYARRAY #define MYARRAY template class MyArray < T arr[N]; public: MyArray(); void Print(); T& operator[](int i); >; #endif 

The source file MyArray.cpp explicitly instantiates template MyArray and template MyArray :

//MyArray.cpp #include #include "MyArray.h" using namespace std; template MyArray::MyArray()<> template void MyArray::Print() < for (const auto v : arr) < cout cout template MyArray; template MyArray; 

In the previous example, the explicit instantiations are at the bottom of the .cpp file. A MyArray may be used only for double or String types.

In C++11 the export keyword was deprecated in the context of template definitions. In practical terms this has little impact because most compilers never supported it.

Источник

C templates cpp files

Tagged as

Stats

Comments and Discussions

I have developed Method 4.

Rename the header file from "Template.h" to "Template.hpp" and alter the cpp include accordingly.

Create a new file "Template.h" with two lines which include both the hpp and cpp.

When the template class is to be used all that is needed is.
#include "Template.h"

From Solution Explorer, right-click on Something.cpp
Configuration Properties
General
Excluded From Build
Yes

Whenever you want to make changes to Something.cpp, you have to do the following:
Include Something.cpp in the build.
In Something.h, comment out #include "Something.cpp".
Build the solution (you may get linker errors).
In Something.h, uncomment #include "Something.cpp".
Exclude Something.cpp from the build.
Build the Solution.

Instead of =>
void TemporaryFunction ()
TestTemp TempObj;
>

template typename Root> class A < . bool isValid(const string& ri); . private: Root * p_root_; >

. bool ARoot>::isValid(const string & ri) < return true; > .

. AC> a; ASSERT_TRUE(a.isValid("blah. "));

It fails link on last a.isValid for Method 3 on G++ 4.9.3 on cygwin:

undefined reference A::isValid(string const*)

Note that the original declare is

A::isValid(string const*): bool

Don't know it's G++ problem or not.

Using Method 2 it passes, but I don't like include test.cc in main.cc though, because the template idea is to have multiple implementation of test.h. Method 2 has to change main.cc each time I have a new implementation.

Got a solution, similar idea:

in test.cc, add one line to TemporaryFunction():

bool TemporaryFunction () < AC> TempObj(""); return TempObj.isValid(""); >

The idea is to put all member functions you are going to use in temp function

In such a case I would suggest a
4th method: explicit template instantiation.
This method requires that you know all the template arguments you will be using before hand. Lets say you will be using an instance of TestTemp with int just do the following in any cpp file.

template class TestTempint>;

Also, if my company was about to agree on using any of those solutions, I would vote for the first and implement a
macro that does the job with an appropriate name such as CompileHelperClassName
The thing is that you don't only need to have a working code but also easy to read, robust and more.
How are you going to document that method? "Helper method in order to compile" ??

I would definitely go for the boost coding style, even without the hpp extension.

Every time you ask the compiler to do something it takes time to do so. Separating implementation from declaration means that the compiler does not need to propagate all that changes every time you change a small thing in the implementation but not the declaration. This saves time. And time is life.

General News Suggestion Question Bug Answer Joke Praise Rant Admin

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Источник