Printable View
What is your preferred way of splitting template classes into a .h and a .cpp file, as is normal with regular classes?
Do you just #include the .cpp file at the bottom of the .h file so the definition and implementation are both in the .h file ready to include to main.cpp or whatever, or do you use some other method? In that case which?
I have always been told that #include'ing .cpp files was bad practice, so which method makes for the best code? Lets get some opinions on this.
You cannot split templates into multiple files.
That was a bit of a blunt answer, no? In theory i guess you are right but in practice you can put the implementation into it's own .cpp file and have the preprocessor move the contents into the .h file before it reaches the compiler.Quote:
Originally Posted by Walle
So i guess what i'm asking is; is this a better approach than just putting all the code in the .h file yourself?
I think it's more consistent, the template classes don't stick out from the rest by not having the implementations in a seperate .cpp file. I was simply requesting some opinions on the matter, how is this problem usually tackled? Does everyone just dump the code in the .h file?
That is false. You can split templates into multiple files -- the problem is that all the files must be included somehow.Quote:
Originally Posted by Walle
This link explains the situation in more detail. Until compilers start supporting the "export" keyword (which may never happen), you will be stuck with including the template implementation.
I'm sorry, I didn't intend to be a wise-ass. I thought I could trust a source such as cplusplus.com, from where I learned that templates can't be split into multiple files. A quote from their tutorial, which i read a few weeks ago:From this page: TemplatesQuote:
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.
Ofc, using my own logical thinking, I should have thought about the possibility to use the preprocessor to move the code around. As I said, I'm sorry, didn't intend to be a wise-ass.
Btw, it made me wonder what else I cannot trust that I read on cplusplus.com...
That is irony. I have been reading that FAQ thoroughly the last few days, I just haven't got to that section yet...As I said, I'm sorry about the misinformation. Thought I could trust cplusplus.com..:(Quote:
Originally Posted by bithub
Personally I like to put regular header stuff in a .h file, and but template implementation in a seperate .hpp file that is included by the .h file.
I've done it that way before. Feels dirty, but gets the job done. Normally though, I just jam everything into a single header file.Quote:
Originally Posted by Neo1
In almost all cases people put it all in a header file. This is the normal thing to do for templates.
The main execption to this is if you only ever intend to use the template inside one cpp file and you can then just dump it all inside that cpp file somewhere above where it is used. That's sometimes just laziness though, and they do this in the article you linked.
Also, if you read it again carefully, especially the last few paragraphs, you'll notice that they don't say anything about splitting template code between header and source files at all.
Ditto that. I've done both and prefer just jamming it all in the header. Either way feels dirty but at least in the header it feels a bit less dirty.Quote:
I've done it that way before. Feels dirty, but gets the job done. Normally though, I just jam everything into a single header file.
When a template is big enough that I don't want to put it all in one header (and some things, like a geospatial index tree, can get very large), I usually put the implementation code in a .ipp file and include that at the bottom of the .hpp file containing the declaration. Sometimes I instead put the implementation in a .hpp file in an impl subdirectory.
The trick is teaching VS to recognize .ipp as source code. I always forget how to do it.
I think it's in in tools->options->text editor
It let's you define different extensions that will still map to use the C++ compiler.
I always put them inside a header and make them inline - ie write the code directly in the definition. I can always use code folding to only see the definitions, and it solves a lot of pain having to duplicate template parameters and friends and stuff when working with templates with separate definition and implementation.