Thread: what's the purpose of virtual functions

It all stems from the concept that a parent object pointer can point to a child object. A virtual function is dynamically bound -- you can call different versions of the same function on an object through a pointer or reference to a base object type and depending on how the function is defined in the child class, you will get the differing results that you want.

Here's a much longer explanation -- I mention virtual functions around the middle.

You just find that you learn a lot when you have no life other than programming.

Here's a shorter explanation. It is a summary of what's in Ivor Horton's Beginning Visual C++ 5.0 book, chapter 10. Suppose you have the following class that contains info on a box's dimensions and methods for outputting the volume of the box to the screen:

Code:

class CBox
{
    public:
        void ShowVolume(void)
        {
            cout << endl << "CBox usable volume is " << Volume();
        }
        double Volume(void)
        {
            return m_Length * m_Height * m_Breadth;
        }
        CBox( double lv=1.0, double bv=1.0, double hv=1.0) : m_Length(lv),
                                                             m_Breadth(bv),
                                                             m_Height(hv)
        {
        }
    protected:
        double m_Length;
        double m_Breadth;
        double m_Height;
}

Now you create a derived class to contain glassware where the volume will be 15% less than the usual volume given by a box with the same dimensions:

Code:

class CGlassBox: public CBox
{
    public:
        double Volume(void)
        {
            return 0.85 * m_Length * m_Breadth * m_Height;
        }
}

If you create and output the volumes of two different boxes using the following program fragment:

Code:

CBox myBox(2.0,3.0,4.0);
CGlassBox myGlassBox(2.0,3.0,4.0);
myBox.ShowVolume();
myGlassBox.ShowVolume();

You get the following results:
CBox usable volume is 24
CBox usable volume is 24

The first result is correct but the second should be 15% less. This is because the call to the Volume() function is being set once by the compiler for the version defined in the base class. This is called static linkage and the call gets fixed to only that version when the code gets compiled. What is needed is to have the actual version of the Volume() function that is called by ShowVolume() function to be determined based on the kind of object being processed in what is know as dynamic linkage. This is why you need virtual functions. Simply adding the word virtual prior to the Volume() function definition in the base class will solve this problem although it is good practice to also put it in the derived class as well. You would then get the proper results:
CBox usable volume is 24
CBox usable volume is 20.4

Originally posted by hk_mp5kpdw
What is needed is to have the actual version of the Volume() function that is called by ShowVolume() function to be determined based on the kind of object being processed in what is know as dynamic linkage.

Watch out, it's dynamic binding, not dynamic linking. Dynamic linking is when the location of the function isn't stored until the executable is run.

Watch out, it's dynamic binding, not dynamic linking. Dynamic linking is when the location of the function isn't stored until the executable is run.

I was doing quite a bit of paraphrasing and summarizing of what was in Ivor Horton's book, the exact mention of this is on page 387 and states as follows:

What we were hoping for in this example was that the question of which Volume() function call to use in any given instance would be resolved when the program was executed. This sort of operation is referred to as dynamic linkage, or late binding. We want the actual version of the function Volume() called by ShowVolume() to be determined by the kind of object being processed, and not arbitrarily fixed by the compiler before the program is executed.

You think he made a mistake?

Originally posted by hk_mp5kpdw
You think he made a mistake?

yup

Bjarne Sroustrup makes the distinction between the two in his book "The design and evolution of C++". The man who created the language keeps the definitions quite seperate.

Yeah, they are entirely different.

Bjarne Sroustrup created C++...which has nothing to do with the use of the terms binding or linking. They are not under c++ or any language. Yes, linking is a word used for something much different than binding. Many programmers also use it to express binding. Words can mean more than one thing, and are generally defined by their usage.

Anyway...for my money I am going with the experianced programmers who have published books and made a name for themseleves over someone who has been programming in c++ for a little over a year.

You come to your own conclusion.


Edit:

http://www.pcwebopaedia.com/TERM/b/bind.html

bind:
To assign a value to a symbolic placeholder. During compilation, for example, the compiler assigns symbolic addresses to some variables and instructions. When the program is bound, or linked, the binder replaces the symbolic addresses with real machine addresses. The moment at which binding occurs is called bind time or link time.

http://www.pcwebopaedia.com/TERM/L/link.html
link:
To bind together.

I think this demonstartes why many programmers use the terms interchangably.