Re: virtual base functions, templates, and static functions
cmonthenet@yahoo.com wrote:
Essentially, it seems like I need something like a virtual static
function (which I know is illegal), but, is there a way to provide
something similar?
Just one note here: since this is not valid in C++, how could anyone tell
what /you/ think it should do?
The class that is the target of my inquiry is a template class that
interfaces to one of several derived classes through a pointer to a
base class.
According to that description you have
template<typename DerivedType>
class target {
Base* base;
void function() {
base->DoSomething();
}
};
The specific derived class that is interfaced to depends
on the template parameter provided.
Okay, that means that by some other information you know that 'base'
actually points to a 'DerivedType'.
However, in a few cases, I need to call a static (class) function
associated with the derived class when an objects of that class may
not exist.
This doesn't make sense. 'virtual' means that the actually called function
depends on the dynamic type of the object it is invoked on. Without an
object, you obviously can't invoke a function. If my assumption above is
correct and you actually know the derived type, you can simply invoke a
static function from it.
Two possibilities I have come up with are to 1) pass the static
function of the dervied class to the target class as a callback
function or 2) add the interface to the abstract base class, remove
the static designation of the function in the derived class, and use
a half-initialized object (ughh!) to access the function through a
pointer to the base class. Is there a better, more elegant way to do
this?
template <typename T>
class Base
{
public:
// illegal to declare a virtual static function here
virtual void func1(T& a) = 0;
virtual void func2(T& b) = 0;
};
class Derived1 : public Base<int>
{
public:
static void Derived1Func(int& x); // type T is int in this
case
void func1(int& a);
void func2(int& b);
};
[...]
class Derived2 : public Base<XyzType>
{
public:
static void Derived2Func(XyzType& x); // type T is XyzType
here
void func1(int& a);
void func2(int& b);
};
Actually, this here would be a bit simpler if Derived1::Derived1Func() and
Derived2::Derived2Func() were just called Derived1::Func() and
Derived2::Func().
template <typename T>
class Target
{
void aFunc(Base<T> *ptr);
void bFunc(Base<T> *ptr);
};
template <typename T>
void Target<T>::aFunc(Base<T> *ptr)
{
T aT;
ptr->func1(T& aT); // great, works fine
};
^
Works fine? Two syntax errors!
template <typename T>
void Target<T>::bFunc(Base<T> *ptr)
{
// now here I need to get a handle on Derived1Func or
// Derived2Func ... or DerivedNFunc depending on the T
// parameter, or some other parameter if necessary. But
// I cannot call any of them directly because this class
// primarily uses an interface to reference the specific
// derived class (and does not know or care which derived
// class it is)
}
This doesn't work. You only know here that 'ptr' is of type 'Base<T>', but
you could have several different classes derived from 'Base<T>', each
providing its own additional interface.
What you could possibly do is something like this (note: I removed it from
the class context of 'Target<T>', because that isn't relevant to this
example):
template<typename DerivedType>
void
function(DerivedType* ptr)
{
// use typedef to extract the parameter for Base<>
typedef typename DerivedType::Parameter Parameter;
// convert to non-template base class, just to check that it is possible
Base<Parameter>* bptr = ptr;
// invoke static function of derived class
Parameter tmp;
DerivedType::Func(tmp);
}
Notes:
- This requires that the template parameter of 'Base<>' is available as a
typedef named 'Parameter'.
- I added the first two lines of code mainly in order to help the compiler
check that the template parameter 'DerivedType' is actually derived from
a 'Base<DerivedParameter>'.
- It further requires that all the static functions are called 'Func()',
otherwise you have to specialise this function for each used type.
Uli
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]