Re: Compile-time polymorphism of "interfaces"
Andrew Schweitzer wrote:
Compile-time polymorphism newbie question here. We are using virtual
functions and getting a performance hit in a device driver. Can some
suggest a way to implement this with templates? We don't actually need
run-time polymorphism, but we do want to share a bunch of code at
compile time.
class IInterface1{public: virtual void DoSomething() = 0;};
class IInterface2{public: virtual void DoSomethingElse() = 0;};
These become concepts (not expressed through some C++ language syntax in
C++03 but will be in C++0x). For now just imagine that a function
implementing the "concept" IInterface1 will have a function with the
signature "void DoSomething();". An equivalent concept for IInterface 2.
class Dervied1 : public virtual IInterface1{
int m_i;
IInterface2* m_pII2;
public:
virtual void DoSomething() {m_i++;}
void UseInterface(){m_pII2->DoSomethingElse();}
}
A class implementing the concept IInterface1 would be a class that has a
function of that signature so we just write a normal function not a virtual
one. Also this class depends on calling of another class function
implementing the second concept. So then we express the dependency as a
template parameter. There are some questions here (because we don't
implement runtime polymorphism) if you really need a pointer/reference at
all for a concept IInterface2 class member. These questions' answer depends
on whather the lifetime of the class implementing the IInterface2 concept
is "bound" to the lifetime of Derived1 (ie each instance of Derived1 has
it's own instance of IInterface2 that dies when Derived1 instance dies).
Having an IInterface2 concept class instance as a data member instead of a
pointer to it offers for more clean management of lifetime dependency
issues. Let's assume it's the case for now.
template<typename IInterface2>
class Derived1 {
int m_i;
IInterface2 m_pII2;
public:
void DoSomething() {m_i++;}
void UseInterface(){m_pII2->DoSomethingElse();}
};
class Dervied1v2 : public virtual IInterface1{
int m_i;
IInterface2* m_pII2;
public:
virtual void DoSomething() {m_i++;}
void UseInterface(){m_pII2->DoSomethingElse();}
}
This is identical to Derived1 I don't get it.
class Dervied2 : public virtual IInterface1{
int m_i;
IInterface1* m_pII1; //Might be a Derived1 or a Derived1v2, but it
would be nice
//to figure out at compile time and
get rid of virtual.
public:
virtual void DoSomethingElse() {m_i++;}
void UseInterface(){m_pII2->DoSomething();}
}
You can figure it out at compile time if you have that information at
compile time. You can have the information as a template parameter. So
Derived2 becomes:
template<typename IInterface1>
class Derived2 {
int m_i;
IInterface1 m_pII1;
public:
virtual void DoSomethingElse() {m_i++;}
void UseInterface(){m_pII2->DoSomething();}
}
The ways I thought of to do this with templates all seemed to have
circular definitions.
Actually you might a lot more often run into circular dependencies with
pointers/references (although you can break them with forward declarations)
than with templates.
--
Dizzy
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]