Keeping the template implementation in .C

[Rene Eng]

Hi there.


"qazmlp" <qazmlp1209@rediffmail.com> schrieb im Newsbeitrag
news:db9bbf31.0307270827.a3053f4@posting.google.co m...

> It is advised to have the template implementation inside header files.
> But, Say, I keep the implementation in .C file. Are there any run time
> problems expected out of this or this is simply a link time problem?
>

I'd say it would not work at all!
It is necessary to compile the whole template code with the type of the
template parameter known, otherwise the compiler can not generate the
correct object code and can not check if the template parameter meets all
requirements (like operators etc.)
In other words: You can create an object of a template module and then
use this object code for different instantiations of the template.

One solution to this problem is to place the definition in the .h file and
the implementation in the .cpp file, but then you have to include the
..cpp file from the .h file, exactly the other way round than it is normally
done.
May be confusing if somebody else is looking at the code.

> Also, I would like to confirm whether having the template
> implementation in .h will increase the executable size for any reason
> compared to its size when the implementation is kept in a .C file.

Since the latter is not possible there is nothing to compare against.
However, the size of your executable will be larger since each template
instantiation generates a new class with all the code of the template.


hth
René



=======================================
C++ sources, cross-platform (UNIX and WinTel) and
covering several topics: [url]http://gemini.futurezone.com[/url]

[Peter van Merkerk]

> > It is advised to have the template implementation inside header files.

> > But, Say, I keep the implementation in .C file. Are there any run time
> > problems expected out of this or this is simply a link time problem?

>
> I'd say it would not work at all!
> It is necessary to compile the whole template code with the type of the
> template parameter known, otherwise the compiler can not generate the
> correct object code and can not check if the template parameter meets all
> requirements (like operators etc.)

That is not entirely true, if the compiler supports the export keyword,
template definitions can be put in a .cpp file. Unfortunately very few
compilers currently do support this keyword. AFAIK only compilers based on
the EDG front end support this keyword.

> In other words: You can create an object of a template module and then
> use this object code for different instantiations of the template.
>
> One solution to this problem is to place the definition in the .h file and
> the implementation in the .cpp file, but then you have to include the
> .cpp file from the .h file, exactly the other way round than it is

normally

> done.
> May be confusing if somebody else is looking at the code.
>

> > Also, I would like to confirm whether having the template
> > implementation in .h will increase the executable size for any reason
> > compared to its size when the implementation is kept in a .C file.

>
> Since the latter is not possible there is nothing to compare against.

Well it is possible, but it is questionable if it will make a big
difference, since basically every time a template is instantiated code
specific for that instantiation must be generated. The only potential saving
I can see is that it might be easier to share code that is independant of
template parameters.

> However, the size of your executable will be larger since each template
> instantiation generates a new class with all the code of the template.

There are ways to avoid, or at least reduce code bloat caused by template
classes.

--
Peter van Merkerk
peter.van.merkerk(at)dse.nl

[Mike Spencer]

qazmlp wrote:

> It is advised to have the template implementation inside header files.
> But, Say, I keep the implementation in .C file. Are there any run time
> problems expected out of this or this is simply a link time problem?
>

This will work, you'll just have to add explicit instantiations in
your .C file for the specializations you need, as the compiler can't
do it for you (without export). You might want to do this if
your implementation requires you to include other header files;
this way you only need to include them in your .C file and users of
your header file will not depend on them.

Mike
--
[url]http://www.lazycplusplus.com/[/url]
The Lazy C++ Programmer's Tool