On 1 Nov, 10:14, Erik Wikström <Erik-wikst...@telia.comwrote:
On 2007-11-01 10:50, nick...@googlemail.com wrote:
If I have a templated constructor, there is a way to know, at compile
time, the instance when compiling the destructor?
To be clearer my problem is that I have a templated constructor that
is empty for particular arguments. I need to have an empty destructor
in this case as well.
Is it possible?
You mean something like this:
#include <iostream>
template<typename T>
class Foo
{
T* t;
public:
Foo();
~Foo();
};
template<typename T>
Foo<T>::Foo()
{
t = new T(); // Should use initialisation list
}
template<typename T>
Foo<T>::~Foo()
{
delete t;
}
template<>
Foo<int>::Foo()
{
}
template<>
Foo<int>::~Foo()
{
}
int main()
{
Foo<doubled;
Foo<inti;
}
When instantiating Foo with an int the special constructor (and later
destructor) will be used. Notice however that I think it is a bad idea
to specialise the destructor if it can be avoided. It is better to just
set t to 0 in Foo<int>'s constructor and not specialise the destructor.
--
Erik Wikström
The problem is that I can not use templated class I can have only
templated constructor
class MyClass
{
template <typename TMyClass(T){ /*Use T as argument for
templates*/}
~MyClass(){ /*Do default action or nothing for particular T used in
the ctor*/}
};
The reason why I can not use template class is that I need to store
them in a Loki::Typelist.
What I'm thinking now is to rely on the compiler optimisation: I set a
non static const in the ctor and I check it in the destructor. This
means that the check is not made at compile time if the compiler does
not optimize the code.
Thanks
