18.1 — Pointers and references to the base class of derived objects

In the previous chapter, you learned all about how to use inheritance to derive new classes from existing classes. In this chapter, we are going to focus on one of the most important and powerful aspects of inheritance -- virtual functions.

But before we discuss what virtual functions are, let’s first set the table for why we need them.

In the chapter on construction of derived classes, you learned that when you create a derived class, it is composed of multiple parts: one part for each inherited class, and a part for itself.

For example, here’s a simple case:

When we create a Derived object, it contains a Base part (which is constructed first), and a Derived part (which is constructed second). Remember that inheritance implies an is-a relationship between two classes. Since a Derived is-a Base, it is appropriate that Derived contain a Base part.

Pointers, references, and derived classes

It should be fairly intuitive that we can set Derived pointers and references to Derived objects:

This produces the following output:

derived is a Derived and has value 5
rDerived is a Derived and has value 5
pDerived is a Derived and has value 5

However, since Derived has a Base part, a more interesting question is whether C++ will let us set a Base pointer or reference to a Derived object. It turns out, we can!

This produces the result:

derived is a Derived and has value 5
rBase is a Base and has value 5
pBase is a Base and has value 5

This result may not be quite what you were expecting at first!

It turns out that because rBase and pBase are a Base reference and pointer, they can only see members of Base (or any classes that Base inherited). So even though Derived::getName() shadows (hides) Base::getName() for Derived objects, the Base pointer/reference can not see Derived::getName(). Consequently, they call Base::getName(), which is why rBase and pBase report that they are a Base rather than a Derived.

Note that this also means it is not possible to call Derived::getValueDoubled() using rBase or pBase. They are unable to see anything in Derived.

Here’s another slightly more complex example that we’ll build on in the next lesson:

This produces the result:

cat is named Fred, and it says Meow
dog is named Garbo, and it says Woof
pAnimal is named Fred, and it says ???
pAnimal is named Garbo, and it says ???

We see the same issue here. Because pAnimal is an Animal pointer, it can only see the Animal portion of the class. Consequently, pAnimal->speak() calls Animal::speak() rather than the Dog::Speak() or Cat::speak() function.

Use for pointers and references to base classes

Now you might be saying, “The above examples seem kind of silly. Why would I set a pointer or reference to the base class of a derived object when I can just use the derived object?” It turns out that there are quite a few good reasons.

First, let’s say you wanted to write a function that printed an animal’s name and sound. Without using a pointer to a base class, you’d have to write it using overloaded functions, like this:

Not too difficult, but consider what would happen if we had 30 different animal types instead of 2. You’d have to write 30 almost identical functions! Plus, if you ever added a new type of animal, you’d have to write a new function for that one too. This is a huge waste of time considering the only real difference is the type of the parameter.

However, because Cat and Dog are derived from Animal, Cat and Dog have an Animal part. Therefore, it makes sense that we should be able to do something like this:

This would let us pass in any class derived from Animal, even ones that we created after we wrote the function! Instead of one function per derived class, we get one function that works with all classes derived from Animal!

The problem is, of course, that because rAnimal is an Animal reference, rAnimal.speak() will call Animal::speak() instead of the derived version of speak().

Second, let’s say you had 3 cats and 3 dogs that you wanted to keep in an array for easy access. Because arrays can only hold objects of one type, without a pointer or reference to a base class, you’d have to create a different array for each derived type, like this:

Now, consider what would happen if you had 30 different types of animals. You’d need 30 arrays, one for each type of animal!

However, because both Cat and Dog are derived from Animal, it makes sense that we should be able to do something like this:

While this compiles and executes, unfortunately the fact that each element of array “animals” is a pointer to an Animal means that animal->speak() will call Animal::speak() instead of the derived class version of speak() that we want. The output is

Fred says ???
Garbo says ???
Misty says ???
Pooky says ???
Truffle says ???
Zeke says ???

Although both of these techniques could save us a lot of time and energy, they have the same problem. The pointer or reference to the base class calls the base version of the function rather than the derived version. If only there was some way to make those base pointers call the derived version of a function instead of the base version…

Want to take a guess what virtual functions are for? :)

Quiz time

1) Our Animal/Cat/Dog example above doesn’t work like we want because a reference or pointer to an Animal can’t access the derived version of speak() needed to return the right value for the Cat or Dog. One way to work around this issue would be to make the data returned by the speak() function accessible as part of the Animal base class (much like the Animal’s name is accessible via member m_name).

Update the Animal, Cat, and Dog classes in the lesson above by adding a new member to Animal named m_speak. Initialize it appropriately. The following program should work properly:

Show Solution

2) Why is the above solution non-optimal?

Hint: Think about the future state of Cat and Dog where we want to differentiate Cats and Dogs in more ways.
Hint: Think about the ways in which having a member that needs to be set at initialization limits you.

Show Solution

18.2 -- Virtual functions and polymorphism
17.x -- Chapter 17 comprehensive quiz

111 comments to 18.1 — Pointers and references to the base class of derived objects

  • Manuel

    If I had a destructor in the Animal class, would it also be "protected"?

  • At the end of the final example, there's a note that states, " can also make m_speak a std::string, but the downside of doing so is..."

    However, the example has m_speak as a std::string. Am I missing something? The word "also" makes me think it's supposed to be different.

  • TimCook

    >> Why do we need an extra pair of curly braces in the second example and we'll get compile error without that? It doesn't make sense.

    >>Would you elaborate on this slicing part a little more?

    what does three iii mean here?

  • srt1104

    I have a few questions regarding Quiz question 1.

    Why are copy constructor and assignment operator function "deleted"?
    Secondly, why are they in protected?
    And lastly, what's the worst that could happen even if they weren't "deleted" and were public?
    As both of them (by default) do memberwise initialization, m_name being a std::string would make a copy for itself and m_speak being a std::string_view would point to the string literal which was available at compile-time. So where does the question of dangling reference/pointer occur?

    • nascardriver

      > Why are copy constructor and assignment operator function "deleted"?
      The comment at those functions was misleading. Deleting them prevents slicing.

      > why are [copy constructor and assignment operator] in protected?
      The public can't create or obtain `Animal` objects, so these functions don't need to be `public`.

      > what's the worst that could happen even if they weren't "deleted" and were public?
      The visibility doesn't matter, but slicing is dangerous. Changes highlighted with ###

      `Cat::make` converts a `Cat` to `Animal`. When this happens, only `Animal`'s data members are copied (Because `Animal(const Animal&)` doesn't know what a `Cat` is. It can only copy its own members.).
      `m_sound` is lost (It's sliced off). `Animal::m_speak` now dangles, accessing it (eg. through `Animal::speak()`) causes undefined behavior.

      I've updated the lesson to use `std::string` for `m_speak`. This solved the undefined behavior issue, but slicing is bad nonetheless. Objects only make sense if they exist as a whole. Slicing is likely to break them.

  • Mince

    You probably forgot to update the text below the code snippet along with the code, animals[iii]->speak() should be animal->speak() to conform to the for each loop in the code.

    While this compiles and executes, unfortunately the fact that each element of array “animals” is a pointer to an Animal means that animals[iii]->speak() will call Animal::speak() instead of the derived class version of speak() that we want.

  • Der_Riese

    > But before we discuss what virtual functions are, let’s first set the table for why we need them.

    I like it ;)

  • ammawn

    "Since a Derived is-a Base"
    should be
    "Since Derived is-a Base"
    I think?

  • Angel

    mm well!! I did it this way
    any suggestion

    #include <iostream>
    #include <string_view>
    #include <string>

    class Animal
        std::string m_name;
        std::string m_speak;

        // We're making this constructor protected because
        // we don't want people creating Animal objects directly,
        // but we still want derived classes to be able to use it.
        Animal(const std::string &name,std::string speak)
            : m_name( name ) ,m_speak(speak) {}

           std:: string spe()const {return  m_name+" says "+m_speak;}

    //    const std::string& getName() const { return m_name; }
        //std::string speak() const { return "???"; }

    class Cat: public Animal{
        Cat(const std::string &name,std::string speak) :Animal (name ,speak){}

    //    std::string speak() const { return "Meow"; }

    class Dog: public Animal
        Dog(const std::string &name,std::string speak) :Animal (name ,speak){}

       // std::string speak() const { return "Woof"; }
    class Duck: public Animal
        Duck(const std::string &name,std::string speak) :Animal (name ,speak){}

       // std::string speak() const { return "Woof"; }

    int main()
    Cat c("Cat","meow");
        Cat c1("Cat","meow");
        Dog p("Dog","wuauww");
        Duck d("duck","cuak");
            std::cout << c.spe();
            std::cout << p.spe();
            std::cout << d.spe();

            Cat array[]={c,c1};
                for(int i=0;i<2;i++){
                std::cout << array[i].spe() <<'\n';

        return 0;

  • aiya

    Hello, thank you for this series of tutorials. They are excellent.
    I'm a little confused about the answer of “Quiz time 1)” (line 56):

    I do not understand the const means here ? and I tried to change the position of "const", and i also deleted "const" , The program can run normally(in visual studio 2019)

    My question is what is the function of const in this sentence?
    Thank you again for these tutorials.

    • nascardriver

      The loop doesn't need to modify the elements. Just like when we mark arguments as `const` when passing a pointer or reference to a function, we do so for loop variables. That way we ensure that we don't accidentally modify something we didn't mean to.

  • Ionut

    =))) Really enjoyed this: "Want to take a guess what virtual functions are for? :)"

    I really appreciate what you do & the effort to constantly update the examples & articles! Keep up the good work! Will certainly try to give back to you if I ever have the possibilities to.

    God Bless and good luck!

    Nonetheless, I do not understand what you meant with the second hint of the second question at the end of the article. And the first two sentences when I press show solution. Will come back to it, though. Am going to re-read the next chapter on virtual functions. Maybe that will clear my misunderstanding out.

  • ErwanDL

    Hey Nascardriver, there are also quite a few "const char*" strings remaining in this article as well. These could surely also be replaced with "std::string" or "std::string_view" as you said earlier (it's a good fit for replacing a const ref to an std::string, right ?).

  • cdecde57

    Hello, I love these tutorials and I have learned so much! I am just wondering if you know anywhere where I can learn about making databases for things like games. I can make simple ones with the fstream library but what I have found is that MySQL is probably a good one to learn and any information on a good place to learn that would be great. Thanks!

  • Udit

    Hello sir,
    Could you tell whether this code would be slower than the one where

    is used, or would there be any chances of dangling references in this code:

    • Hello Udit!

      * Initialize your variables with brace initializers.
      * Line 13: Limit your lines to 80 characters in length for better readability on small displays.
      * Line 35: No need for a reference, you can loop through the pointers directly.
      * Don't use "using namespace".
      * @Animal::getName and @Animal::speak should be const.

      > Could you tell whether this code would be slower
      Yes. @std::string is pretty much always slower than using C-style strings. The easier use of @std::string outweighs the performance benefits of const char*. Unless you're running on a system with highly limited resources, use @std::string.

      > would there be any dangling references in this code
      There are none.

  • Louis Cloete

    Hi Alex! Two things:

    1) Why don't you use const std::string&s for the constructor parameters? It works, and might just copy the whole object around less, but I am not sure exactly how it works. Can you maybe enlighten me?

    2) After the stricter error levels you suggested, this solution will not compile yet again. You need to add

    Here is my full code (split into a separate header for each class and updated with C++11 concepts like a for-each loop for exercise):





    • Louis Cloete

      Another question: I forgot to #include "animal.h" in cat.h and dog.h, yet the program still compiled and ran as expected. Why is that? I would've thought that would not compile?

    • 1) You should pass by const reference.

      > I forgot to #include "animal.h
      #includes are handled by the preprocessor. It just copies the contents of the included file into the including file.
      Since you're including @"animal.h" before "cat.h" and "dog.h", the declaration of @Animal exists when the declarations of @Cat and @Dog are encountered. If you include @"animal.h" after one of the other headers, you'll get an error.

    • Alex

      Lesson updated. It is interesting to note that this style of initialization:

      uses the copy constructor -- hence, if you delete the copy constructor, this won't compile any longer.

      • SALAH

        Hi Alex,
        Why such an initializing use 'Copy constructor'? Wouldn't the compiler optimize that making it {"Fread", "Misty", "zeke"} ?

  • lucieon

    Hi Alex,

    When we use "const char*" as the return type in speak() function, is the string(Either "???" or "Meow" or "Woof") created only once in memory?

    Also if we use "const std::string&" as the return type, does deep copying still occur? or does it work just like "const char*"?

    • Alex

      Maybe. C-style string literals have special handling, and identical C-style string literals may or may not be consolidated into a single entry.

      If you return a const std::string&, then you'll end up returning a hanging reference (the C-style string literal would get implicitly converted into a std::string, which would go out of scope when the function returned). You'd have to return by value instead. Better to return the C-style string and let the caller convert to a std::string if that's what they want.

  • Silviu

    In the quiz, doesn't use shallow copy ? even if are using string on speak ?

    • Alex

      There isn't any copying going on in the quiz.

      Also, std::string knows how to do a deep copy, so even if we did copy an object (using the default copy constructor), std::string would function correctly.

      Or did I miss the point?

  • Andi

    Typo in Pointers, references, and derived classes:
    Missing the backslash of '\n' in line 12. :)

  • sam

    I think there's a slight typo in relation to a misplaced comma:

    "The problem, is of course, that because..." ---> "The problem is, of course, that because..."

  • Zixin

    Thanks for this great guide! Alex, I suggest you to consider having some kind of a membership for learners who dont like ads, instead of everyone just installing Ads Blocker. Without Ads, this page is clean and more comfortable to read.

    • Alex

      Thanks for the suggestion! I've thought about it. But having a membership means the site now has to deal with:
      * User accounts
      * Billing
      * Customer support

      That adds a lot of complexity to what is already a fairly time-intensive hobby site. :)

  • Nick Eh 30

    Why are you using const char* instead of const std::string*?

    • Alex

      To avoid having to create a std::string object every time the function is called. The user can always construct a std::string from the const char* return value if they want to work with or manipulate the string further.

      • Dants

        Hi Alex ,

        Any particular reason to use std::string for m_name?
        I understand that the advantage of using const char* is that the same string literal may be consolidated into a single value for optimization purposes. But since m_name will be different for every animal, m_name can never enjoy this optimization.
        Still, are there any reasons to use std::string (and return by std::string) for m_name? Since m_name will only be used for printing to the console, I don't see any reason not making it a const char* as well.


  • DecSco

    "yip"? Aren't you thinking of Ewoks here? :D

  • An unrelated question about the return type used for the speak() function.

    const char* speak() { return "???"; }

    Alex, is there any reason why you use C-style const char* instead of const std::string? Is 'string' inefficient here because that would return by-copy? I'm aware that we can't return by reference here.

    • Alex

      "???" is of type const char*, so that's what the function returns (to avoid conversions). Using std::string as a return value would work, but it would cause a std::string to get constructed every time this function was called, which is inefficient.

  • Ran

    Is this an explanation of 12.2.2 ?

    The programmer will encounter the difficult in constructing the
    derived classes. For example, one wants to add a private member in the
    Cat class:

    If you construct the Cat instance like the following code:

    Then the code will not work as you expected. You will have hard time
    in constructing a private member in the Cat class.

  • Ran

    Hi I just want to verity this performance of two kinds of string. I
    sometimes encounters the cases where C-style is weaker than
    std::string. Although most of the time, C-style is faster, but only a

    Fred says Meow
    Garbo says Woof
    Misty says Meow
    Pooky says Woof
    Truffle says Woof
    Zeke says Meow
    Time elapsed:(Std::string) 0.00173975
    Fred says Meow
    Garbo says Woof
    Misty says Meow
    Pooky says Woof
    Truffle says Woof
    Zeke says Meow
    Time elapsed:(CStyle) 0.00174155
    Press any key to continue . . .

    This is my test code. In case someone may interested in.

Leave a Comment

Put all code inside code tags: [code]your code here[/code]