C / C++ / MFC

10-May-05 0:11

Hello,

I have a little problem with virtual functions in derived classes. The problem is that I want to call a virtual function in my base class CBase. This function is abstract in this class. In the derived class CDerived this function is implemented. When the code in the base class gets executed, the _purecall handler is invoked. This means that I call a non-existing (abstract) function which is not implemented.

Here is the sample code:

<br />
class CBase<br />
{<br />
public:<br />
virtual void Foo() = 0; // abstract function<br />
<br />
// static cast is used to avoid unresolved external symbol error<br />
void DoFoo() { static_cast<CBase*>(this)->Foo(); }<br />
};<br />
<br />
class CDerived : public CBase<br />
{<br />
public:<br />
virtual void Foo() { /**/ }<br />
};<br />

As you can see, I want to supply an interface in which certain functionality is provided. Some core functionality depends on ssituation specific user code, which should be supplied in the derived class.

Does anybody know how to solve this problem?

I also got the blogging virus..[^]

Cedric Moonen10-May-05 0:28

Cedric Moonen

10-May-05 0:28

I don't understand what you really want to do...
Virtual functions are used like in the following case:

CBase* pClass = new CDerived;<br />
pClass->Foo();

In this case, the function that will be called is the derived function. The thing I don't understand is why do you want to call the redifined Foo function from within the base class ??? D'Oh! | :doh:

Why not simply call the Foo function directly ?

Maybe because you want this function to do something common for every class ? But then a much better solution would be to call from within your redifined Foo function a function from the base class.

Bob Stanneveld10-May-05 1:09

10-May-05 1:09

cedric moonen wrote:
Virtual functions are used like in the following case:

CBase* pClass = new CDerived;
pClass->Foo();

No, the purpose of virtual functions is that the correct function is called when the exact type of a class is not known. For exemple:

<br />
class A<br />
{ <br />
public:<br />
virtual void Foo() {}<br />
};<br />
<br />
class B<br />
{<br />
public:<br />
virtual void Foo() {}<br />
};<br />
<br />
A* pA = new B;<br />
pA->Foo(); // calls B::Foo<br />

cedric moonen wrote:
In this case, the function that will be called is the derived function. The thing I don't understand is why do you want to call the redifined Foo function from within the base class ???

The base class (the interface) relies on functionality that cannot be implemented at that level, but the general functionality is always the same...

So the user must supply some functionality that is different for each use of the class.

cedric moonen wrote:
Why not simply call the Foo function directly ?

What do you mean by that, calling the function directly. If you mean that I should cast to the derived type, I cannot. This is because I don't know which one of the infinitly amount of possible derived classes would be calling the function.

cedric moonen wrote:
Maybe because you want this function to do something common for every class ? But then a much better solution would be to call from within your redifined Foo function a function from the base class.
In the most cases this would be the better solution, but in my particular case, it requires more than just 2 lines of code that will need to be rewritten every time a new class is derived from the base class.

I have a couple of dozen lines that are identical for every case, but the implementation of a function in the middle of those lines is user specific. I need to call that function from the base class, because I cannot rely on the end user to execute certain code before and after the call. Besides that, I don't want the user to write all those lines over and over again...

I also got the blogging virus..[^]

Cedric Moonen10-May-05 1:34

Cedric Moonen

10-May-05 1:34

Bob Stanneveld wrote:
No, the purpose of virtual functions is that the correct function is called when the exact type of a class is not known. For exemple:

class A
{
public:
virtual void Foo() {}
};

class B
{
public:
virtual void Foo() {}
};

A* pA = new B;
pA->Foo(); // calls B::Foo

This won't work the compiler will complain because it cannot cast from B* to A*. What you need to add in your code is that B derives from A and that's exactly the same explanation I gave you. Virtual functions are used only with inheritance.

Bob Stanneveld wrote:
What do you mean by that, calling the function directly. If you mean that I should cast to the derived type, I cannot. This is because I don't know which one of the infinitly amount of possible derived classes would be calling the function.

As you explained above, when you have this code:

class A<br />
{ <br />
public:<br />
virtual void Foo() {}<br />
};<br />
<br />
class B : public A<br />
{<br />
public:<br />
virtual void Foo() {}<br />
};<br />
<br />
A* pA = new B;<br />
pA->Foo(); // calls B::Foo

You don't need to know the type of child class at compile time. The correct derived function will automatically be called.

Bob Stanneveld wrote:
I have a couple of dozen lines that are identical for every case, but the implementation of a function in the middle of those lines is user specific

Ok, now I understand a little bit better the problem and what you want to achieve. But unfortunately, if you want to do that, you will need to know the type of the class in which you want to cast. Also, I think there is a missing part in your code with the static_cast operator (the text between the < > was removed). I think you'll need to post it again because it is the most important part of the code Wink | ;)

S. Senthil Kumar10-May-05 1:43

10-May-05 1:43

I guess he missed out B deriving from A by mistake. That apart, I don't see why the type of the class needs to be known. That's what virtual functions are for, aren't they?

And he had casted it to Base *. (I found out by looking at the HTML source).

Regards
Senthil
_____________________________
My Blog | My Articles | WinMacro

Cedric Moonen10-May-05 2:01

Cedric Moonen

10-May-05 2:01

S. Senthil Kumar wrote:
I guess he missed out B deriving from A by mistake

That was my guess also but then it is exactly the same that I explained Smile | :)

S. Senthil Kumar wrote:
That apart, I don't see why the type of the class needs to be known. That's what virtual functions are for, aren't they?

Yes when you call the function from outside the class with a pointer. Here what he wants to do is call a function from the base class (that just exist in the base class) then call from within this function the derived function Foo. But from within the class, if you call it directly, you will call the function from the base class and not from the derived class (not using the virtual table). So to make it work you need to cast the this pointer into the child class thus it has to be known ! Maybe the missing part in the code was that I tried to cast into the base class but that won,t work neither...

S. Senthil Kumar10-May-05 2:14

10-May-05 2:14

No, it doesn't matter whether you're calling the virtual function from outside the class or inside. As long as you're using a pointer to the class, you should be fine. If you call it from within the base class, the call will get translated to this->Func(); which is the same as p->Func() where p is a pointer to Base.

class Base
{
public:
	virtual void Stop() = 0;

	void SomeFunc()
	{
		Stop();
	}
};

class Derived : public Base
{
public:
	void Stop()
	{
		cout << "Derived" ;
	}
};

int main()
{
	Base * b = new Derived();
	b->SomeFunc();
}

This piece of code prints Derived as expected.

Regards
Senthil
_____________________________
My Blog | My Articles | WinMacro

Tim Smith12-May-05 4:01

Tim Smith

12-May-05 4:01

Just watch out during construction and destruction when the vtable is changing all the time.

Tim Smith

I'm going to patent thought. I have yet to see any prior art.

S. Senthil Kumar10-May-05 1:10

10-May-05 1:10

My guess is you haven't overridden the virtual function correctly. Maybe it has fewer or more parameters than the original function, maybe it's misspelled. Also, I don't really see why you should be using a static_cast to call a virtual function.

Regards
Senthil
_____________________________
My Blog | My Articles | WinMacro

Bob Stanneveld10-May-05 1:14

10-May-05 1:14

S. Senthil Kumar wrote:
My guess is you haven't overridden the virtual function correctly

If that would be the case, than the compiler would complain about instantiating abstract classes, since not all abstract functions have been implemented...

S. Senthil Kumar wrote:
Also, I don't really see why you should be using a static_cast to call a virtual function.

This would be, because the compiler complains about unresolved external symbols if I omit that. I thought that this should invoke a virtual function call using a pointer from the v-table, but something is terribly wrong and I don't know what.

I also got the blogging virus..[^]

S. Senthil Kumar10-May-05 1:19

10-May-05 1:19

Yeah, you're right. Can you post the full code? Maybe that'll help.

Regards
Senthil
_____________________________
My Blog | My Articles | WinMacro

Bob Stanneveld10-May-05 1:51

10-May-05 1:51

The simplified code of the base class

<br />
template <class T><br />
class IMultiThreaded : protected A, public B<T>, public C, public D<br />
{<br />
public:<br />
virtual ~CBase();<br />
<br />
vitual DWORD Stop(DWORD* pdwCode, DWORD dwWaitTimeOut = DEFAULT_TIMEOUT) = 0;<br />
};<br />
<br />
// implementation of CBase<br />
template <class T><br />
CBase<T>::~CBase()<br />
{<br />
if( m_bSomeConstant ) Stop(NULL); /* static cast removed. Must solve unresolved external symbol error */<br />
}<br />

The code of the derived class:

<br />
<class><br />
template <class T><br />
class CDerived : public CBase<T><br />
{<br />
public:<br />
virtual ~CDerived() { }<br />
virtual DWORD Stop(DWORD* pdwCode, DWORD dwWaitTimeOut = DEFAULT_TIMEOUT);<br />
}<br />
<br />
// implementation of CDerived<br />
template <class T><br />
DWORD CDerived<T>::Stop(DWORD *pdwCode, DWORD dwWaitTimeOut)<br />
{<br />
// some code<br />
}<br />

I also got the blogging virus..[^]

S. Senthil Kumar10-May-05 2:05

10-May-05 2:05

It looks like you are calling the virtual function from the destructor. That's a big no-no.

The order of destructor execution in C++ is such that by the time you're in the destructor of your base class, the derived part of your instance is already gone. The compiler is intelligent enough to figure that out and decides to call the base class function itself. In your case, it is pure virtual and so you are getting the unresolved external symbol error.

If you static cast it to Base explicitly, I guess the compiler assumes you know what you are doing and calls the virtual function anyway. But at runtime, it'll blow up badly.

Regards
Senthil
_____________________________
My Blog | My Articles | WinMacro

Bob Stanneveld10-May-05 2:15

10-May-05 2:15

Well, I guess that I have to find an other way to cleanup automatically... Thanks for the information Big Grin | :-D

!

I also got the blogging virus..[^]

S. Senthil Kumar10-May-05 2:20

10-May-05 2:20

Just make the destructor virtual. That should solve your problem.

Regards
Senthil
_____________________________
My Blog | My Articles | WinMacro

Bob Stanneveld10-May-05 3:07