Return instances of an abstract class without slicing

Question

Is there a way to return different variations of an abstract class in a function without losing information to slicing?

As in, let's say I have an abstract class Dog, and for dog there are WildDog, DomesticDog, Puppy.

Is it possible to create a function that takes in one of these function and return them without slicing information?

Example:

// Returns the type of dog you currently have
Dog getCurrentDog() {
    return this.dog;
}

void setDog(Dog dog) {
    this.dog = dog;
}

Is it possible to pass in WildDog or PuppyDog to setDog and retain all the information in the respective classes. Say for an example PuppyDog has a drinkMilk() function that the other dogs don't have, but I still want to be able to access it.

And if possible, what would the Java equivalent be?

The solution I'm thinking of right now would be to have a getDog() for each of the instances of Dog that return the specific instance of the dog, whether it be Puppy or WildDog. That way, I can specifically access the code in each class.

Answer 1

To avoid slicing, you need to pass a pointer or reference to a Dog. See object slicing.

std::shared_ptr<Dog> getCurrentDog()
{
    return dog;
}

In order to use functions in PuppyDog etc, you would need to declare them virtual in your abstract Dog class, or dynamic_cast. dynamic_cast usually indicates poor design, but as it is, all dogs can drink milk, so it makes sense to declare them in your Dog class:

class Dog
{
    public:
        virtual void drinkMilk(); // not pure virtual: all dogs can drink milk
};

class PuppyDog : public Dog
{
    public:
       // puppies drink less milk, and do it more messily
       void drinkMilk() override;
};

Now you can have the following:

 // getCurrentDog is a PuppyDog
 std::shared_ptr<Dog> myDog = someOwner.getCurrentDog();
 myDog->drinkMilk();

There are plenty of instances this works for: play(), rollOver(), fetch(), and all other things all dogs can do; however, say you had some functionality that not all dogs could do, and only a PuppyDog could. You could still create a function in your base class, and could declare it pure virtual, or you could dynamic_cast to a PuppyDog:

// This if will only succeed if getCurrentDog is a PuppyDog (or something inherited PuppyDog) and if getCurrentDog != nullptr
if (std::shared_ptr<PuppyDog> myPuppy = std::dynamic_pointer_cast<PuppyDog>(someOwner.getCurrentDog()))
{
     // do something only a puppy would:
     myPuppy->beExtremelyCute();
}

As @PaulMcKenzie points out, it is quite often a design flaw and drifts away from object-oriented programming (because you end up with "if it's a WildDog, do this; if it's a PuppyDog, do this" etc)

Answer 2

polymorphism is often better expressed as an implementation detail of a wrapper class. This gives you a heterogeneous interface which can, for example be stored in vectors and copied without slicing.

I have included a working example below.

Notice that the implementation of the various types of dog are not actually polymorphic - dog, puppy and wild_dog.

The polymorphism is introduced as an implementation detail of the general dog class, doggie.

#include <iostream>
#include <typeinfo>
#include <memory>
#include <string>
#include <utility>
#include <type_traits>
#include <vector>

// default cases
template<class T>
void do_howl(const T&)
{
    std::cout << "a " << T::dog_type() << " cannot howl" << std::endl;
}

template<class T>
void do_be_cute(const T&)
{
    std::cout << "a " << T::dog_type() << " is not cute" << std::endl;
}


// now provide specialisations
struct dog
{
    dog(std::string s) : name(std::move(s)) {}
    std::string name;
    static const char* dog_type() { return "normal dog"; }
};

void do_howl(const dog& d)
{
    std::cout << "the dog called " << d.name << " is howling" << std::endl;
}


struct puppy
{
    puppy(std::string s) : name(std::move(s)) {}
    std::string name;
    std::string cute_noise() const { return "yip yip!"; }
    static const char* dog_type() { return "puppy"; }
};

void do_be_cute(const puppy& p)
{

    std::cout << "aww! the cute little puppy called " << p.name << " is barking: " << p.cute_noise() << std::endl;
}

struct wild_dog
{

    static const char* dog_type() { return "wild dog"; }
};

void do_howl(const wild_dog& d)
{
    std::cout << "the nameless wild dog called is howling" << std::endl;
}

struct doggy {

    struct concept {

        virtual void be_cute() const = 0;
        virtual void howl() const = 0;

    };

    template<class T>
    struct model : concept
    {
        model(T&& t) : _t(std::move(t)) {}
        model(const T& t) : _t(t) {}

        void be_cute() const override
        {
            do_be_cute(_t);
        }

        void howl() const override
        {
            do_howl(_t);
        }

        T _t;
    };

    void howl() const {
        _impl->howl();
    }

    void be_cute() const {
        _impl->be_cute();
    }

    template<class T, std::enable_if_t<!std::is_base_of<doggy, T>::value>* = nullptr>
    doggy(T&& t) : _impl(std::make_shared<model<T>>(std::forward<T>(t)))
    {}


    std::shared_ptr<concept> _impl;
};

int main()
{
    std::vector<doggy> dogs = {
        doggy(dog("rover")),
        doggy(puppy("poochums")),
        doggy(wild_dog())
    };

    for (const auto& d : dogs)
    {
        d.howl();
        d.be_cute();
    }

    return 0;
}

expected output:

the dog called rover is howling
a normal dog is not cute
a puppy cannot howl
aww! the cute little puppy called poochums is barking: yip yip!
the nameless wild dog called is howling
a wild dog is not cute

In this particular case, the doggie has shared-implementation semantics. If you wanted distinct copies to be made, replace the shared_ptr with a unique_ptr, provide a copy constructor and add a clone() method to the concept (with corresponding implementation in the model).