Re: Support for export keyword ?
James Kanze wrote:
Could you give some examples of the difficulties which pop up
with that?
Could you explain to me why you think it is so simple.
Because you can emulate export templates to a degree with manual
instantiation.
In other words, in the header file you can simply have the declaration
of the template class or template function (ie. not its definition), and
then in a source file you can implement the definition and then in that
file instantiate it manually for each type with which the template is
being used in the program.
I have done that in practice and it works.
One would think that it wouldn't be so much different as when
the programmer does the same thing "manually".
The programmer never does the same thing manually. To do so
would be too difficult.
It's quite simple to do, at least for simple template types. For example:
//-----------------------------------------------------------------
// EmulatedExportTemplateClass.hh
template<typename Value_t>
class EmulatedExportTemplateClass
{
Value_t value;
public:
EmulatedExportTemplateClass(const Value_t&);
const Value_t& getValue() const;
};
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// EmulatedExportTemplateClass.cc
#include "EmulatedExportTemplateClass.hh"
template<typename Value_t>
EmulatedExportTemplateClass<Value_t>::EmulatedExportTemplateClass
(const Value_t& v):
value(v)
{}
template<typename Value_t>
const Value_t& EmulatedExportTemplateClass<Value_t>::getValue() const
{
return value;
}
// Manual "export" template instantiation:
template class EmulatedExportTemplateClass<int>;
template class EmulatedExportTemplateClass<double>;
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// main.cc
#include "EmulatedExportTemplateClass.hh"
#include <iostream>
int main()
{
EmulatedExportTemplateClass<int> intVal(10);
EmulatedExportTemplateClass<double> doubleVal(2.5);
std::cout << intVal.getValue() << " " << doubleVal.getValue()
<< std::endl;
}
//-----------------------------------------------------------------
In other words, when the programmer/linker sees that a
template is instantiated with type X, the programmer/linker
goes to the source file where the template is defined and adds
an explicit instantiation of it for X and then recompiles that
one object file, and that's about it.
Except that the results won't compile.
The above example compiles at least with gcc and Visual C++.
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---