Using virtual functions

Any class that contains a pure virtual function is an abstract class and cannot be instantiated. It is only used as a base class that can be built upon. Any class derived from an abstract will have to implement the pure virtuals or it becomes an abstract class also. In your class A the function f() contains no implementation so any derived class must implement that function using whatever code is appropriate. If you want two versions of f(), one in A and one in B then don't make it pure virtual in A.

The problem is that I don't know how A::f() is even implemented (in my test program I do, but in the SDK I don't.).

Since A::f() is pure virtual, is there no way to use it? I'm assuming that I cannot modify class A in any way.


By definition, pure virtual functions don't exist. Theres no code there. Its blank. And such a class can never be instantiated. None of the existing compilers allow that. You got to roll out your own if you need to. Such classes as 'A' are supposed to be just a layout for anything that wants to act as 'A', remember?

Imagine this. Theres a wall on a high raise room with a door called exit. Theres nothing on the other side. If you attempt to use it any way then you'll be a splat. You are supposed to provide a means of exit; be it a fire ladder, a staircase, a lift, a rocket - anything that suits your purpose.

So, don't worry about not knowing if and how that function is implemented 'cause its not. NOT. Theres nothing, null, cipher, sonne, duck, love...

IF you know the pure virtual function has a definition then the only way you're going to call it is to do so explicitly. In the example you gave you can use an object of class B:

int main()
{
    B b;
    b.A::f();
}

Of course if the library hasn't implemented the pure virtual function then you'll get some sort of warning like "Pure virtual function called" and your code will crash in a heap.

If there aren't any derived classes of A that you can explicitly call through you'll have to derive your own class and override the virtual function:

class C : public A
{
    public:
        virtual void f()
        {
            A::f();
        }
};

int main()
{
    C c;
    c.f();
}

Again, if A::f() hasn't an implementation then your code is on the way to crash city.

Normally when you declare a function as pure virtual you're not going to implement it as pure virtual functions specify an interface. Having said that there are two main reasons why you'd implement a pure virtual function:

- destructors need a body, even if pure virtual

- to provide default behaviour for a virtual function but make the deriver explicitly say they want the default behaviour.

Cheers,

Ash

thanks folks.

Just for future reference, if I made a class that had pure virtual functions in it, I would do this to force the user implement a function with the same name/type as the pure virtual functions that I created? Maybe this is used for other non virtual functions in my class and such? There's probably a whole host of reasons to do this I guess.

retVal = aPtr->f() ; //access violation (since f() = 0 right?)

No. "An access violation" in your example occurs since aPtr is not pointing to a valid object. Calling aPtr->f() in a context in which only a polymorphic type A is known is the basic virtue of polymorphism. Your SDK is dealing with object (better "interfaces") which "behave as A" no matter of which late type (in your case B) they are.

To access A's f() you need to do this: aPtr->A::f()

Since this is virtual function if you just call aPtr->f() it'll always resolve to the most derived class version of f().

http://simplestcodings.blogspot.com

Edited by Ash to clarify an ambiguous statement of what's called when.