Access protected members of an existing base object

Question

Lets say I have a base class with protected member:

class Base  
{
public:
    Base(int data)
    : m_attribute(data) {}

protected:
    int m_attribute;
};

and derived class from base:

class Derived : public Base 
{
 public:
    int get_attribute()
    {
        return m_attribute;
    }   
};

First of all: I can do this, right? Is this totally legal?

If yes, then here is the question:

• I can't change anything in a Base class;
• I have a Base class object, and I need to access its m_attribute member;

Should I do downcasting from this base class object to derived class object first, and then call get_attribute() function? Something like this:

Base base(5);
Derived* derived = static_cast < Derived*>(&base);
int base_attribute = derived->get_attribute();

Or what are other ways to access protected member? I know that friend function is an option, but I can't change anything in the base class

Answer 1

Should I do downcasting from this base class object to derived class object first, and then call get_attribute() function?

Most definitely not. An instance of a base class is not an instance of a derived class. Your conversion is ill-formed.

Here is a valid way:

struct kludge : Base {
    kludge(const Base& b): Base(b) {}
    operator int() {
        return m_attribute;
    }
};

usage:

Base base(5);
int foo = kludge(base);

This kludge works by copy constructing the base sub object of the derived type. This of course depends on the base being copyable - which your Base is. It's easy to tweak to work with movable as well.

As a syntactic sugar, the kludge is implicitly convertible to the type of the member. If you prefer, you could use a getter.

Answer 2

if base class doesn't have a default constructor after overloading it to take some arguments and no default one is there then the derived classes must use member-initializer list to initialize the base part otherwise you cannot instantiate the derived class getting the compiler complaining about missing default constructor in base class:

class Base  
{
    public:
    //  Base(){} default constructor by default the compiler creates one for you unless you overload it so the next one taking one parameter will hide this one
        Base(int data) // hides the default ctor so derived classes must use member-initializer list
        : m_attribute(data) {}

    protected:
        int m_attribute;
};


class Derived : public Base 
{
    public:
        Derived() : Base(0){} // you must use member intializer list to initialize the part Base
        //Derived(int x) : Base(x){} // also ok
        int get_attribute(){ return m_attribute; }   
};

int main()
{
    Derived dervObj;

    Derived* derived = static_cast < Derived*>(&baseObj);
    int base_attribute = derived->get_attribute();
    cout << base_attribute << endl;

}

• also you cannot cast the address of class base to derived object but cast an object of base class to derived one.

so in your example writing in main:

Derived* derived = static_cast < Derived*>(&baseObj); // is like writing:
char* cp = static_cast < char*>(&int); // you must convert a variable not a type

• why you want to access protected members from outside??? keep in mind that public inheritance will copy all the members of base to derived class but private.

• using friendship or making member data public will make it possible to access it from outside but it undermines the principles of data-hiding and encapsulation however friendship in some cases it's a must and there's no other alternative then use it carefully but making data public it's better to get back to structs

Answer 3

The Derived class can access and modify the public and protected Base class properties and methods.

Then, you can't case Base into Derived. Derived inherit from Base, so Derived is a Base. But a Base is not a Derived (a Car is a Vehicle, a Vehicle is not a Car).

So if you need a getter, put it directly into Base, or instanciate a Derived instead of a Base.

Answer 4

Firstly:

Derived* derived = static_cast < Base*>(base);

This is not valid and illegal. Won't compile. You can't static cast Base to Base*.

And to answer your question:

Base base(5);
Derived& derived = static_cast<Derived&>(base);
std::cout << derived.get_attribute();

Or if you want to use a pointer because you think you're cooler:

Base base(5);
Derived* derived = static_cast<Derived*>(&base);
std::cout << derived->get_attribute();

EDIT: static_cast doesn't have any overhead on runtime. It is static, hence it's a compile-time thing. Both methods will yield the same result.