C++: Cast parent class to child class

Question

I'm fairly new to C++ and this is the problem I have: I have two classes, Client and Host. And when everything is loaded you have the option to press two buttons, if you press button 1 Client is loaded and if you press button 2 Host is loaded.

Now both Client and Host are fairly big classes, and I don't want to put them both into the memory. So my idea was creating a Base class, and then both Client and Host should extend the base class, and then the only thing I had to do was this:

Base connection;

//If button 1 is pressed:
connection = Client();

//If button 2 is pressed:
connection = Host();

Well this sounded almost too good to be true, and when I tried it I got no errors. Now comes the problem, Base has a function called A, and Client has a function called B. So the function B is unique to the class Client.

When I try to call function B I get this error: 'class Base' has no member named 'B'. How can I let C++ know that I am talking to class Client or Host instead of Base? I am also open for a whole new approach to this problem. Maybe it's just an error in my thinking process.

Thanks in advance!

Answer 1

You ran into a situation which we call object slicing, which is a common problem in languages with value semantics such as C++.

Object slicing happens when you assign a value of a sub-type to a new location (your variable connection) of a super type. This introduces a new copy of the instance, but of the super type, not the sub-type, so you lose the information about the concrete class you wanted to instantiate.

To avoid this, you have multiple options.

The classical approach uses pointers:

Base * connection;
connection = new YourConcreteType();

Then, to use this object, you have to derefrerence it using the asterisk operator (*):

(*connection).function();
connection->function();    // syntactic sugar, semantically equivalent

Not to forget: You have to delete the object after usage:

delete connection;

To simplify this, C++ introduces two concepts: references and smart pointers. While the former has a restriction to be only assigned once, it is the syntactically simplest one. The latter is similar to the pointer approach, but you don't have to care about deletion, so you less likely run into a memory leak situation:

std::shared_ptr<Base> connection;

connection = make_shared<YourConcreteType>(); // construction via 'make_shared'

// ... use as if it were just a pointer ...

connection->function();

// no delete!

There are also other "smart pointer" types, like unique_ptr, which can be used if you do not intend to pass the pointer around (if it stays in scope).

Now, you can implement the functions in both classes separately. To make use of polymorphism, this means, during runtime, either the function of the one subclass or of the other subclass is called, depending on which one was constructed, you should declare the functions in the base class as being virtual, otherwise, the function definition in Base will be called, regardless of the concrete type you have constructed.

In your case, you want to call a function which should do something different, depending on the type. While your approach was to introduce two different functions, namely A and B, you can just declare a single function, let's call it handleEvent, as a pure virtual (= abstract) function in the base class, which means "this function is to be implemented in sub classes", and define it in the two subclasses independently:

Base {
    ....
    virtual void handleEvent(...) = 0; // "= 0" means "pure"
};

// Don't provide an implementation

Client {
    void handleEvent(...); // override it
};

// define it for Client:
void Client::handleEvent(...) {
    ...
}

Host {
    void handleEvent(...); // override it
};

// define it for Host:
void Host::handleEvent(...) {
    ...
}

Answer 2

When you do this:

Base connection;

You create an object connection that has exactly the memory needed for type Base.

When you do this:

connection = Client();

you are not expanding the memory allocated or converting connection into a Client instance. Instead, you are creating a bigger object that gets "sliced" into a smaller one.

What you want to do, is use pointers (or references or smart pointers) so that what you keep is just an address of an object that might be one type or the other type. Like this:

Base *connection;
...
connection = new Client();

The first statement creates a pointer to a Base typed object, and the second one allocates the memory for a Client typed one, initializes it and assigns its address to connection.

Answer 3

If you want to use Base still then you are going to have to do this to use those functions:

if (Button1) {
    dynamic_cast<Client*>(connection)->A();
} else {
    dynamic_cast<Host*>(connection)->B();   
}  

And you will need to make connection a pointer. Base * connection.

This isn't really ideal though. You should investigate a different way to do it like in the other answers.

Answer 4

First, this line

connection = Client();

is using the assignment operator to set the state of connection, a Base, from a temporary Client object. connection is still a Base object. What you can do is the following:

std::unique_ptr<Base> makeBase(someFlagType flag)
{
  if (flag) {
    return std::unique_ptr<Base>(new Cient);
  } else {
    return std::unique_ptr<Base>(new Host);
  }
}

Then

std::unique_ptr<Base> b = makeBase(myFlag);
b->someBaseMethod();

Concerning the casting part, I would say that if you find yourself having to cast to a child type, you should re-think the design of the classes.