Passing a casted type around

Question

I have kind of a diamond kind of inheritance. But that is not the problem. I am passing a casted type through a setter method. However when I try to recast it to its original type I get bad_cast. Code snippet of the problem below. What am I doing wrongly and how can I fix it.

#include <iostream>

class Animal {
public:
    virtual ~Animal() {}

    void SetName(const std::string name) {
        name_ = name;
    }

    std::string const &Name() {
        return name_;
    }

private:
    std::string name_;
};


class AnimalA : virtual public Animal {
public:

};

class AnimalB : virtual public Animal {
public:

};

class AnimalAB : public AnimalA, AnimalB {
public:

};

Animal h;

void GetAnimal(const Animal &animal) {
    h = animal;
}

int main() {
    Animal *animal = new AnimalA();
    GetAnimal(*animal);
     AnimalA f = dynamic_cast<AnimalA&>(h);
    return 0;
}

[Object slicing](https://stackoverflow.com/questions/274626/what-is-object-slicing)? — Algirdas Preidžius, Mar 24 '21 at 12:37
Does this answer your question? [What is object slicing?](https://stackoverflow.com/questions/274626/what-is-object-slicing) — Simon Kraemer, Mar 24 '21 at 12:37
in some sense, object slicing is just the symtpom. If your design is not flawed, you shouldn't need such casting — 463035818_is_not_an_ai, Mar 24 '21 at 12:39
@largest_prime_is_463035818 Looking at what I want to achieve from the snippet above, what will you suggest to be a good design. — r360, Mar 24 '21 at 12:46

Serge Ballesta · Answer 1 · 2021-03-24T13:34:56.917

C++ is not Java nor Python. In those language, a variable is only a reference to an object, so it could also contain a instance of a subclass. C++ has objects, pointers and 2 kinds of references (lvalue and rvalue). Both pointers and references can be used for instances of subclasses, but objects cannot because of the slicing problem.

Here the design problem is that you have a global Animal object that you want to be able to receive an instance of AnimalA subclass. This is simply not possible in C++.

If you have no ownership constraints, you could use a raw pointer for h, because it would be natively polymorphic:

const Animal *h;

void GetAnimal(const Animal &animal) {
    h = &animal;
}

int main() {
    Animal *animal = new AnimalA();
    GetAnimal(*animal);
    const AnimalA *pf = dynamic_cast<const AnimalA*>(h);
    AnimalA f;
    if (pf != NULL) {
         f = *pf;       // successful copy assignment from the initial AnimalA object
    }
    del animal;         // never forget to destroy what has been allocated
    return 0;
}

It you do not want to be bothered by the new, del question, you could use an automatic object instead of a dynamic one:

    ...
    AnimalA animal;
    GetAnimal(animal);
    ...

Passing a casted type around

1 Answers1