C++

Pointers and references to the base class of derived objects

2013-04-07T19:12:00.003+05:30

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:

class Base

{

protected:

    int m_nValue;

public:

    Base(int nValue)

        : m_nValue(nValue)

    {

    }

    const char* GetName() { return "Base"; }

    int GetValue() { return m_nValue; }

};

class Derived: public Base

{

public:

    Derived(int nValue)

        : Base(nValue)

    {

    }

    const char* GetName() { return "Derived"; }

    int GetValueDoubled() { return m_nValue * 2; }

};

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 of it.

Pointers, references, and derived classes

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

int main()

{

    using namespace std;

    Derived cDerived(5);

    cout << "cDerived is a " << cDerived.GetName() << " and has value " << cDerived.GetValue() << endl;

    Derived &rDerived = cDerived;

    cout << "rDerived is a " << rDerived.GetName() << " and has value " << rDerived.GetValue() << endl;

    Derived *pDerived = &cDerived;

    cout << "pDerived is a " << pDerived->GetName() << " and has value " << pDerived->GetValue() << endl;

    return 0;

}

This produces the following output:

cDerived 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!

int main()

{

    using namespace std;

    Derived cDerived(5);

    // These are both legal!

    Base &rBase = cDerived;

    Base *pBase = &cDerived;

    cout << "cDerived is a " << cDerived.GetName() << " and has value " << cDerived.GetValue() << endl;

    cout << "rBase is a " << rBase.GetName() << " and has value " << rBase.GetValue() << endl;

    cout << "pBase is a " << pBase->GetName() << " and has value " << pBase->GetValue() << endl;

    return 0;

}

This produces the result:

cDerived 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() is an override of Base::GetName(), 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:

#include <string>

class Animal

{

protected:

    std::string m_strName;

    // 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(std::string strName)

        : m_strName(strName)

    {

    }

public:

    std::string GetName() { return m_strName; }

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

};

class Cat: public Animal

{

public:

    Cat(std::string strName)

        : Animal(strName)

    {

    }

    const char* Speak() { return "Meow"; }

};

class Dog: public Animal

{

public:

    Dog(std::string strName)

        : Animal(strName)

    {

    }

    const char* Speak() { return "Woof"; }

};

int main()

{

    Cat cCat("Fred");

    cout << "cCat is named " << cCat.GetName() << ", and it says " << cCat.Speak() << endl;

    Dog cDog("Garbo");

    cout << "cDog is named " << cDog.GetName() << ", and it says " << cDog.Speak() << endl;

    Animal *pAnimal = &cCat;

    cout << "pAnimal is named " << pAnimal->GetName() << ", and it says " << pAnimal->Speak() << endl;

    Animal *pAnimal = &cDog;

    cout << "pAnimal is named " << pAnimal->GetName() << ", and it says " << pAnimal->Speak() << endl;

    return 0;

}

This produces the result:

cCat is named Fred, and it says Meow
cDog 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 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 like this:

void Report(Cat &cCat)

{

    cout << cCat.GetName() << " says " << cCat.Speak() << endl;

}

void Report(Dog &cDog)

{

    cout << cDog.GetName() << " says " << cDog.Speak() << endl;

}

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:

void Report(Animal &rAnimal)

{

    cout << rAnimal.GetName() << " says " << rAnimal.Speak() << endl;

}

This would let us pass in any class derived from Animal, even ones that we haven’t thought of yet! Instead of one function per animal, we get one function that works with all classes derived from Animal!

The problem, is of course, that because cAnimal is an Animal reference, cAnimal.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 do it like this:

Cat acCats[] = { Cat("Fred"), Cat("Tyson"), Cat("Zeke") };

Dog acDogs[] = { Dog("Garbo"), Dog("Pooky"), Dog("Truffle") };

for (int iii=0; iii < 3; iii++)

    cout << acCats[iii].GetName() << " says " << acCats[iii].Speak() << endl;

for (int iii=0; iii < 3; iii++)

    cout << acDogs[iii].GetName() << " says " << acDogs[iii].Speak() << endl;

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 Animal, it makes sense that we should be able to do something like this:

Cat cFred("Fred"), cTyson("Tyson"), cZeke("Zeke");

Dog cGarbo("Garbo"), cPooky("Pooky"), cTruffle("Truffle");

// Set up an array of pointers to animals, and set those pointers to our Cat and Dog objects

Animal *apcAnimals[] = { &cFred, &cGarbo, &cPooky, &cTruffle, &cTyson, &cZeke };

for (int iii=0; iii < 6; iii++)

    cout << apcAnimals[iii]->GetName() << " says " << apcAnimals[iii]->Speak() << endl;

While this compiles and executes, unfortunately the fact that apcAnimals is a pointer to an Animal means that apcAnimals[iii]->Speak() will call Animal::Speak() instead of the proper derived class version of Speak().

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? :)

Virtual base classes

2013-04-07T19:09:00.001+05:30

Note: This section is an advanced topic and can be skipped or skimmed if desired.

In the previous section on multiple inheritance, we left off talking about the “diamond problem”. In this section, we will resume this discussion.

Virtual base classes

Here is our example from the previous lesson, with some constructors:

class PoweredDevice

{

public:

    PoweredDevice(int nPower)

    {

        cout << "PoweredDevice: " << nPower << endl;

    }

};

class Scanner: public PoweredDevice

{

public:

    Scanner(int nScanner, int nPower)

        : PoweredDevice(nPower)

    {

        cout << "Scanner: " << nScanner << endl;

    }

};

class Printer: public PoweredDevice

{

public:

    Printer(int nPrinter, int nPower)

        : PoweredDevice(nPower)

    {

        cout << "Printer: " << nPrinter << endl;

    }

};

class Copier: public Scanner, public Printer

{

public:

    Copier(int nScanner, int nPrinter, int nPower)

        : Scanner(nScanner, nPower), Printer(nPrinter, nPower)

    {

    }

};

If you were to create a Copier class object, by default you would end up with two copies of the PoweredDevice class — one from Printer, and one from Scanner. This has the following structure:

We can create a short example that will show this in action:

int main()

{

    Copier cCopier(1, 2, 3);

}

This produces the result:

PoweredDevice: 3
Scanner: 1
PoweredDevice: 3
Printer: 2

As you can see, PoweredDevice got constructed twice.

While this is sometimes what you want, other times you may want only one copy of PoweredDevice to be shared by both Scanner and Printer. To share a base class, simply insert the “virtual” keyword in the inheritance list of the derived class. This creates what is called a virtual base class, which means there is only one base object that is shared. Here is the an example (without constructors for simplicity) showing how to use to virtual keyword to create a shared base class:

class PoweredDevice

{

};

class Scanner: virtual public PoweredDevice

{

};

class Printer: virtual public PoweredDevice

{

};

class Copier: public Scanner, public Printer

{

};

Now, when you create a Copier class, you will get only one copy of PoweredDevice that will be shared by both Scanner and Printer.

However, this leads to one more problem: if Scanner and Printer share a PoweredDevice base class, who is responsible for creating it? The answer, as it turns out, is Copier. The Copier constructor is responsible for creating PoweredDevice. Consequently, this is one time when Copier is allowed to call a non-immediate-parent constructor directly:

class PoweredDevice

{

public:

    PoweredDevice(int nPower)

    {

        cout << "PoweredDevice: " << nPower << endl;

    }

};

class Scanner: virtual public PoweredDevice

{

public:

    Scanner(int nScanner, int nPower)

        : PoweredDevice(nPower)

    {

        cout << "Scanner: " << nScanner << endl;

    }

};

class Printer: virtual public PoweredDevice

{

public:

    Printer(int nPrinter, int nPower)

        : PoweredDevice(nPower)

    {

        cout << "Printer: " << nPrinter << endl;

    }

};

class Copier: public Scanner, public Printer

{

public:

    Copier(int nScanner, int nPrinter, int nPower)

        : Scanner(nScanner, nPower), Printer(nPrinter, nPower), PoweredDevice(nPower)

    {

    }

};

This time, our previous example:

int main()

{

    Copier cCopier(1, 2, 3);

}

produces the result:

PoweredDevice: 3
Scanner: 1
Printer: 2

As you can see, PoweredDevice only gets constructed once.

There are a few details that we would be remiss if we did not mention.

First, virtual base classes are created before non-virtual base classes, which ensures all bases get created before their derived classes.

Second, note that the Scanner and Printer constructors still have calls to the PoweredDevice constructor. If we are creating an instance of Copier, these constructor calls are simply ignored because Copier is responsible for creating the PoweredDevice, not Scanner or Printer. However, if we were to create an instance of Scanner or Printer, the virtual keyword is ignored, those constructor calls would be used, and normal inheritance rules apply.

Third, if a class inherits one or more classes that have virtual parents, the most derived class is responsible for constructing the virtual base class. In this case, Copier inherits Printer and Scanner, both of which have a PoweredDevice virtual base class. Copier, the most derived class, is responsible for creation of PoweredDevice. Note that this is true even in a single inheritance case: if Copier was singly inherited from Printer, and Printer was virtually inherited from PoweredDevice, Copier is still responsible for creating PoweredDevice.

C++ Program with dynamic memory allocation with new keyword

2013-01-18T20:41:00.000+05:30

C:\Users\Jatinder\Desktop\example27_cpp.html <!-- Exported by C-Free C/C++ IDE

#include<iostream.h>
#include<conio.h>
int main()
{
 clrscr();
 int *pArr=new int[10];
 int *pin=new int;
 cout<<"Enter the number of elements in an array"<<endl;
 cin>> *pin;
 cout<<"Enter the elements one by one" <<endl;
 for (int i=0; i<*pin; i++)
     {
  cin>>pArr[i];
     }
 cout<<"Array elements are"<<endl;
 for (int j=0; j<*pin; j++)
   {
  cout<<endl<<pArr[j];
   }
 delete pin;
 delete[]pArr;
 getch();
 return 0;
}

-->

Multiple inheritance

2013-01-13T14:29:00.001+05:30

So far, all of the examples of inheritance we’ve presented have been single inheritance — that is, each inherited class has one and only one parent. However, C++ provides the ability to do multiple inheritance. Multiple inheritance enables a derived class to inherit members from more than one parent.

Let’s say we wanted to write a program to keep track of a bunch of teachers. A teacher is a person. However, a teacher is also an employee (they are their own employer if working for themselves). Multiple inheritance can be used to create a Teacher class that inherits properties from both Person and Employee. To use multiple inheritance, simply specify each base class (just like in single inheritance), separated by a comma.

#include <string>

class Person

{

private:

    std::string m_strName;

    int m_nAge;

    bool m_bIsMale;

public:

    Person(std::string strName, int nAge, bool bIsMale)

        : m_strName(strName), m_nAge(nAge), m_bIsMale(bIsMale)

    {

    }

    std::string GetName() { return m_strName; }

    int GetAge() { return m_nAge; }

    bool IsMale() { return m_bIsMale; }

};

class Employee

{

private:

    std::string m_strEmployer;

    double m_dWage;

public:

    Employee(std::string strEmployer, double dWage)

        : m_strEmployer(strEmployer), m_dWage(dWage)

    {

    }

    std::string GetEmployer() { return m_strEmployer; }

    double GetWage() { return m_dWage; }

};

// Teacher publicly inherits Person and Employee

class Teacher: public Person, public Employee

{

private:

     int m_nTeachesGrade;

public:

    Teacher(std::string strName, int nAge, bool bIsMale, std::string strEmployer, double dWage, int nTeachesGrade)

        : Person(strName, nAge, bIsMale), Employee(strEmployer, dWage), m_nTeachesGrade(nTeachesGrade)

    {

    }

};

Problems with multiple inheritance

While multiple inheritance seems like a simple extension of single inheritance, multiple inheritance introduces a lot of issues that can markedly increase the complexity of programs and make them a maintenance nightmare. Let’s take a look at some of these situations.

First, ambiguity can result when multiple base classes contain a function with the same name. For example:

class USBDevice

{

private:

    long m_lID;

public:

    USBDevice(long lID)

        : m_lID(lID)

    {

    }

    long GetID() { return m_lID; }

};

class NetworkDevice

{

private:

    long m_lID;

public:

    NetworkDevice(long lID)

        : m_lID(lID)

    {

    }

    long GetID() { return m_lID; }

};

class WirelessAdaptor: public USBDevice, public NetworkDevice

{

public:

    WirelessAdaptor(long lUSBID, long lNetworkID)

        : USBDevice(lUSBID), NetworkDevice(lNetworkID)

    {

    }

};

int main()

{

    WirelessAdaptor c54G(5442, 181742);

    cout << c54G.GetID(); // Which GetID() do we call?

    return 0;

}

When c54G.GetID() is evaluated, the compiler looks to see if WirelessAdaptor contains a function named GetID(). It doesn’t. The compiler then looks to see if any of the base classes have a function named GetID(). See the problem here? The problem is that c54G actually contains TWO GetID() functions: one inherited from USBDevice, and one inherited from WirelessDevice. Consequently, this function call is ambiguous, and you will receive a compiler error if you try to compile it.

However, there is a way to work around this problem: you can explicitly specify which version you meant to call:

int main()

{

    WirelessAdaptor c54G(5442, 181742);

    cout << c54G.USBDevice::GetID();

    return 0;

}

While this workaround is pretty simple, you can see how things can get complex when your class inherits from four or six base classes, which inherit from other classes themselves. The potential for naming conflicts increases exponentially as you inherit more classes, and each of these naming conflicts needs to be resolved explicitly.

Second, and more serious is the diamond problem, which your author likes to call the “diamond of doom”. This occurs when a class multiply inherits from two classes which each inherit from a single base class. This leads to a diamond shaped inheritance pattern.

For example, consider the following set of classes:

class PoweredDevice

{

};

class Scanner: public PoweredDevice

{

};

class Printer: public PoweredDevice

{

};

class Copier: public Scanner, public Printer

{

};

Scanners and printers are both powered devices, so they derived from PoweredDevice. However, a copy machine incorporates the functionality of both Scanners and Printers.

There are many issues that arise in this context, including whether Copier should have one or two copies of PoweredDevice, and how to resolve certain types of ambiguous references. While most of these issues can be addressed through explicit scoping, the maintenance overhead added to your classes in order to deal with the added complexity can cause development time to skyrocket.

Is multiple inheritance more trouble than it’s worth?

As it turns out, most of the problems that can be solved using multiple inheritance can be solved using single inheritance as well. Many object-oriented languages (eg. Smalltalk, PHP) do not even support multiple inheritance. Many relatively modern languages such as Java and C# restricts classes to single inheritance of normal classes, but allow multiple inheritance of interface classes (which we will talk about later). The driving idea behind disallowing multiple inheritance in these languages is that it simply makes the language too complex, and ultimately causes more problems than it fixes.

Many authors and experienced programmers believe multiple inheritance in C++ should be avoided at all costs due to the many potential problems it brings. Your author does not agree with this approach, because there are times and situations when multiple inheritance is the best way to proceed. However, multiple inheritance should be used extremely judiciously.

As an interesting aside, you have already been using classes written using multiple inherited without knowing it: the iostream library objects cin and cout are both implemented using multiple inheritance.

Adding, changing, and hiding members in a derived class

2013-01-13T14:13:00.001+05:30

In the introduction to inheritance lesson, we mentioned that one of the biggest benefits of using derived classes is the ability to reuse already written code. You can inherit the base class functionality and then add new functionality, modify existing functionality, or hide functionality you don’t want. In this lesson, we’ll take a closer look at how this is done.

First, let’s start with a simple base class:

#include <iostream>

using namespace std;

class Base

{

protected:

    int m_nValue;

public:

    Base(int nValue)

        : m_nValue(nValue)

    {

    }

    void Identify() { cout << "I am a Base" << endl; }

};

Now, let’s create a derived class that inherits from Base. Because we want Derived to be able to set the value of m_nValue when Derived objects are instantiated, we’ll make the Derived constructor call the Base constructor in the initialization list.

class Derived: public Base

{

public:

    Derived(int nValue)

        :Base(nValue)

    {

    }

};

We’ll develop Derived over the course of this lesson.

Adding new functionality

Because we have access to the source code of the Base class, we could add functionality directly to Base. However, there may be times when we do not want to, or can not. Consider the case where you have just purchased a library of code from a 3rd party vendor, but need some extra functionality. You could add to the original code, but this isn’t the best solution. What if the vendor sends you an update? Either your additions will be overwritten, or you’ll have to manually migrate them. It’s also common to for developers to release header files containing class definitions, but release the implementation code precompiled — this means you can use the code, but you won’t have the ability to modify it directly.

In either case, the best answer is to derive your own class, and add the functionality you want to the derived class.

One obvious omission from the Base class is a way for the public to access m_nValue. Normally we’d write an access function in the Base class — but for the sake of example we’re going to add it to the derived class instead. Because m_nValue has been declared as protected in the Base class, Derived has direct access to it.

To add new functionality to a derived class, simply declare that functionality in the derived class like normal:

class Derived: public Base

{

public:

    Derived(int nValue)

        :Base(nValue)

    {

    }

    int GetValue() { return m_nValue; }

};

Now the public will be able to call GetValue() in order to access the value of m_nValue.

int main()

{

    Derived cDerived(5);

    cout << "cDerived has value " << cDerived.GetValue() << endl;

    return 0;

}

This produces the result:

cDerived has value 5

Although it may be obvious, objects of type Base have no access to the GetValue() function in Derived. The following does not work:

int main()

{

    Base cBase(5);

    cout << "cBase has value " << cBase.GetValue() << endl;

    return 0;

}

This is because there is no GetValue() function in Base. GetValue() belongs to Derived. Because Derived is a Base, Derived has access to stuff in Base. However, Base does not have access to anything in Derived.

Redefining functionality

When a member function is called with a derived class object, the the compiler first looks to see if that member exists in the derived class. If not, it begins walking up the inheritance chain and checking whether the member has been defined in any of the inherited classes. It uses the first one it finds.

Consequently, take a look at the following example:

int main()

{

    Base cBase(5);

    cBase.Identify();

    Derived cDerived(7);

    cDerived.Identify()

    return 0;

}

This prints

I am a Base
I am a Base

When cDerived.Identify() is called, the compiler looks to see if Identify() has been defined in the Derived class. It hasn’t. Then it starts looking in the inherited classes (which in this case is Base). Base has defined a Identify() function, so it uses that one. In other words, Base::Identify() was used because Derived::Identify() doesn’t exist.

However, if we had defined Derived::Identify() in the Derived class, it would have been used instead. This means that we can make functions work differently with our derived classes by redefining them in the derived class!

In our above example, it would be more accurate if cDerived.Identify() printed “I am a Derived”. Let’s modify Identify() so it returns the correct response when we call Identify() with a Derived object.

To modify a function the way a function defined in a base class works in the derived class, simply redefine the function in the derived class.

class Derived: public Base

{

public:

    Derived(int nValue)

        :Base(nValue)

    {

    }

    int GetValue() { return m_nValue; }

    // Here's our modified function

    void Identify() { cout << "I am a Derived" << endl; }

};

Here’s the same example as above, using the new Derived::Identify() function:

int main()

{

    Base cBase(5);

    cBase.Identify();

    Derived cDerived(7);

    cDerived.Identify()

    return 0;

}

I am a Base
I am a Derived

A word of warning: the prototype (return value, function name, and parameters) of the function in the derived class must be exactly identical to that in the base class. If the return value does not match, the compiler will issue an error. If the parameters or function name are different, C++ will treat this as an added function rather than a modified function!

Also note that when you redefine a function in the derived class, the derived function does not inherit the access specifier of the function with the same name in the base class. It uses whatever access specifier it is defined under in the derived class. Therefore, a function that is defined as private in the base class can redefined as public in the derived class, or vice-versa!

Adding to existing functionality

Sometimes we don’t want to completely replace a base class function, but instead want to add additional functionality to it. In the above example, note that Derived::Identify() completely hides Base::Identify()! This may not be what we want. It is possible to have our Derived function call the Base function of the same name (in order to reuse code) and then add additional functionality to it.

To have a derived function call a base function of the same name, simply do a normal function call, but prefix the function with the scope qualifier (the name of the base class and two colons). The following example redefines Derived::Identify() so it first calls Base::Identify() and then does it’s own additional stuff.

class Derived: public Base

{

public:

    Derived(int nValue)

        :Base(nValue)

    {

    }

    int GetValue() { return m_nValue; }

    void Identify()

    {

        Base::Identify(); // call Base::Identify() first

        cout << "I am a Derived"; // then identify ourselves

    }

};

Now consider the following example:

int main()

{

    Base cBase(5);

    cBase.Identify();

    Derived cDerived(7);

    cDerived.Identify()

    return 0;

}

I am a Base
I am a Base
I am a Derived

When cDerived.Identify() is executed, it resolves to Derived::Identify(). However, the first thing Derived::Identify() does is call Base::Identify(), which prints “I am a Base”. When Base::Identify() returns, Derived::Identify() continues executing and prints “I am a Derived”.

This is all pretty straightforward. The real lesson to take away from this is that if you want to call a function in a base class that has been redefined in the derived class, you need to use the scope resolution operator (::) to explicitly say which version of the function you want.

If we had defined Derived::Identify() like this:

void Identify()

{

    Identify(); // Note: no scope resolution!

    cout << "I am a Derived"; // then identify ourselves

}

Identify() without a scope resolution qualifier would default to the Identify() in the current class, which would be Derived::Identify(). This would cause Derived::Identify() to call itself, which would lead to an infinite loop!

Hiding functionality

In C++, it is not possible to remove functionality from a class. However, it is possible to hide existing functionality.

As mentioned above, if you redefine a function, it uses whatever access specifier it’s declared under in the derived class. Therefore, we could redefine a public function as private in our derived class, and the public would lose access to it. However, C++ also gives us the ability to change a base member’s access specifier in the derived class without even redefining the member! This is done by simply naming the member (using the scope resolution operator) to have it’s access changed in the derived class under the new access specifier.

For example, consider the following Base:

class Base

{

private:

    int m_nValue;

public:

    Base(int nValue)

        : m_nValue(nValue)

    {

    }

protected:

    void PrintValue() { cout << m_nValue; }

};

Because Base::PrintValue() has been declared as protected, it can only be called by Base or it’s derived classes. The public can not access it.

Let’s define a Derived class that changes the access specifier of PrintValue() to public:

class Derived: public Base

{

public:

    Derived(int nValue)

        : Base(nValue)

    {

    }

    // Base::PrintValue was inherited as protected, so the public has no access

    // But we're changing it to public by declaring it in the public section

    Base::PrintValue;

};

This means that this code will now work:

int main()

{

    Derived cDerived(7);

    // PrintValue is public in Derived, so this is okay

    cDerived.PrintValue(); // prints 7

    return 0;

}

Note that Base::PrintValue does not have the function call operator (()) attached to it.

We can also use this to make public members private:

class Base

{

public:

    int m_nValue;

};

class Derived: public Base

{

private:

    Base::m_nValue;

public:

    Derived(int nValue)

    {

         m_nValue = nValue;

    }

};

int main()

{

    Derived cDerived(7);

    // The following won't work because m_nValue has been redefined as private

    cout << cDerived.m_nValue;

    return 0;

}

Note that this allowed us to take a poorly designed base class and encapsulate it’s data in our derived class.
(Alternatively, instead of inheriting Base’s members publicly and making m_nValue private by overriding it’s access specifier, we could have inherited Base privately, which would have caused all of Base’s member to be inherited privately in the first place).

One word of caution: you can only change the access specifiers of base members the class would normally be able to access. Therefore, you can never change the access specifier of a base member from private to protected or public, because derived classes do not have access to private members of the base class.