Re: I need help understanding inheritance and virtual functions

dwightarmyofchampions@hotmail.com wrote:


  I think the C++ streams are a perfect example of object-oriented
programming (including dynamic binding, ie. virtual functions) in
action. For example, suppose you have a function like this:

void printSomethingTo(std::ostream& os)
{
    os << "Something";
}

  std::ostream is a *base class* from which several other types of
stream classes have been derived. The printSomethingTo() function above
takes a reference of this base class type, but doesn't really know what
it's really given. However, it doesn't have to: It can still output the
string to whatever it was given, as long as it has been derived from
that base class.

  The idea is that you can give it *different* types of objects as
parameter, and it will work with all of them. Example:

    std::ofstream outputFile("somefile.txt");
    printSomethingto(outputFile); // prints to a file

    std::ostringstream aStringStream;
    printSomethingTo(aStringStream); // prints to memory

    printSomethingTo(std::cout); // prints to standard output

  Note that the printSomethingTo() function is compiled only once, and
exists only once in the program. It's *not* compiled again for each
possible type it's given as parameter. (printSomethingTo() might even be
eg. in a precompiled library, and in the program itself you don't even
see how it has been implemented.) Yet still the above works: The
function is able to output the string to different targets without
problems. That's dynamic binding (ie. virtual functions) in action.