Virtual

Hi

Just have a few questions
1. Virtual functions can be accessed using object pointers only ??
2. We cannot have virtual constructors but we can have virtual destructors ??

:confused:

1. They can be accessed through pointers and references. They cannot be accessed through an instance of a class itself simply because an instance of the class must be of that particular type, and not a derived type.

2. Virtual destructors are allowed (and often a good idea), but it wouldn't make sense to have virtual constructors (after all, you call the constructor of the type of object you want to create, right). That said, you should be mindful to call the appropriate base class constructor in the constructor of your derived classes (this point is not directly related, but does go along with the theme of inheritance and constructors).

Quote:

---

Originally Posted by aldajlo

1. Virtual functions can be accessed using object pointers only ??

---

No, virtual functions can be accessed the same way regular functions can, through pointers, references or actual object instances.

The benefits of a virtual function - basically the fact that you can call a virtual function from a base class pointer or reference and the correct derived class version of that virtual function will be executed - only apply to pointers and references. This makes sense, because the point is to have a base class pointer (or reference) pointing to a derived class object. Only pointers or references can point to object instances in this way.

Quote:

---

Originally Posted by aldajlo

2. We cannot have virtual constructors but we can have virtual destructors ??

---

Correct. It doesn't make sense to have a virtual constructor, because when you are constructing an object you know what type that object is. A virtual function is needed for when you have a base class pointer (or reference) and you don't know what type of derived class it points to. At the time of construction, you know the type of derived class you are constructing.

At the time of destruction, it is possible to delete a base class pointer that points to a derived class. In that case, you want to make sure the appropriate destructors are called, which is why the destructor can (and always should) be virtual when using inheritance polymorphically.

To clarify my first statement to be consistent with jlou's, while you can call a virtual function from an actual instance of the object, it does not make use of the fact that the function is virtual (that is, the instance cannot actually be an instance of the derived type, so it works the same as if it was non-virtual.

That said, jlou's description is probably more coherent anyway. :)

Ok, now I have a question about this...

Code:

---

#include<iostream>

class A{
public:
        A(){}
        void p(){std::cout << "A.p();\n";}
};
class B: public A{
public:
        B(){}
        void p(){std::cout << "B.p();\n";}
};

class C{
public:
        C(){}
        virtual void p(){std::cout << "C.p();\n";}
};
class D: public C{
public:
        D(){}
        virtual void p(){std::cout << "D.p();\n";}
};

int main(int argc, char* argv[]){
        A a;
        B b;
        a.p();
        b.p();
        static_cast<A>(b).p();       
       
        C c;
        D d;
        c.p();
        d.p();
        static_cast<C>(d).p();

        std::cout<<"\nszA: "<<sizeof(A)<<" szB: "<<sizeof(B);
        std::cout<<"\nszC: "<<sizeof(C)<<" szD: "<<sizeof(D)<<"\n";
        return 0;
}
//OUTPUT
A.p();
B.p();
A.p();
C.p();
D.p();
C.p();

szA: 1 szB: 1
szC: 4 szD: 4

---

Souldn't it be...

Code:

---

//OUTPUT
A.p();
B.p();
A.p();
C.p();
D.p();
D.p();
...

---

The virtual function pointer isn't being assigned, or it's changed in the casting

No... that is the point about virtual functions only working virtually when called from pointers or references. When you use the static cast, it slices the D-ness off of the D object and converts the object to type C. At that point, you are calling p() on a C object, not a D object.

More appropriate casts might be:

Code:

---

int main()
{
    D d;
    static_cast<C&>(d).p();
    static_cast<C*>(&d)->p();
}

---

They don't change the object, just how it is referred to.

Ahh!! Thank you...
Arhum... Now I see that with my static_cast I create a new C object. References or pointers refer always to my original D object.