Question

免责声明：只有在想要了解它是如何完成时才继续阅读。显然你错了，当你看到它会从中得到眼癌（我很幸免，因为我是菜鸟:)

所以我在C ++中思考运行时多态性已有一段时间了，我想出了以下内容。考虑一下这个

#include <iostream>

struct Animal
{
    virtual ~Animal(){}
    void make_noise() const {return do_make_noise();}
    protected:
    Animal( ){}
    virtual void do_make_noise()const{std::cout << "Meh\n";}
};
struct Cat:public Animal
{
    void do_make_noise()const{ std::cout<< "meow\n";}
};
struct Dog:public Animal
{
    void do_make_noise()const{ std::cout<< "woof\n";}
};

int main()
{
    Cat cat;
    Dog dog;
    Animal a((const Animal&)cat); //every tutorial teaches us that this is bad!!
    a.make_noise();
    a = (const Animal&)dog;
    a.make_noise();
    return 0;
}

正如您所期望的那样输出

Meh
Meh

好的，对象切片很糟糕：/
但现在让我稍微改变Base类：

struct Animal
{
    virtual ~Animal(){}
    void make_noise() const {return ptr_->do_make_noise();}
    protected:
    Animal( ):ptr_(this){}
    Animal* ptr_;
    virtual void do_make_noise()const{std::cout << "Meh\n";}
};

然后结果是

meow
woof

哈哈。螺旋物切片...
你怎么看呢？在我看来，能够按值复制并仍然获得多态行为有许多优点。人们不使用这个有原因吗？或者我只是在这里重新发明轮子？

Answer 1

您编写的代码未显示未定义的行为，并且确实“阻止对象切片”;相反，它是非常脆弱和不可维护的。

每个Animal现在都拥有一个非托管指针，指向它所扮演的某些ur-Animal（有时是它自己）。您的代码违反了合理复制和移动构造的含义。

实际上，它避免了崩溃和未定义的行为，但只是偶然。轻微的看似无害的调整和你的程序休息。

写一个返回动物的函数？您的代码会中断，具体取决于省略。从本地Animal复制到传入的引用，然后返回？破碎。把它们放在标准载体中？彻底的灾难。

创建没有遭受切片的值语义多态类型看起来有点像这样，但是你从pImpl拥有的值类型拆分虚拟层次结构，并且实例拥有 pImpl指向的内容。 / p>

struct IAnimal{
  virtual void speak() const=0;
  virtual std::unique_ptr<IAnimal> clone() const = 0;
  virtual ~IAnimal(){}
};
struct Animal {
  std::unique_ptr<IAnimal> pImpl;
  void speak() const { if (pImpl) pImpl->speak(); }
  explicit operator bool()const{return (bool)pImpl;}
  Animal(Animal&&)=default;
  Animal& operator=(Animal&&)=default;
  Animal(Animal const&o):
    Animal(o.pImpl?Animal(o.pImpl->clone()):Animal())
  {}
  Animal()=default;
  Animal& operator=(Animal const& o){
    Animal tmp(o);
    swap(pImpl, tmp.pImpl);
    return *this;
  }
  Animal(std::unique_ptr<IAnimal> x):pImpl(std::move(x)){}
};

现在Animal无法切片，可以是多态的。

struct Dog:Animal{
  struct IDog:IAnimal{
    std::unique_ptr<IAnimal> clone()const final override{ return std::make_unique<IDog>(*this); }
    void speak()const final override { std:cout <<"woof\n"; }
  };
  Dog():Animal(std::make_unique<IDog>()){}
};  
struct Cat:Animal{
  struct ICat:IAnimal{
    std::unique_ptr<IAnimal> clone()const final override{ return std::make_unique<ICat>(*this); }
    void speak()const final override { std:cout <<"meow\n"; }
  };
  Cat():Animal(std::make_unique<ICat>()){}
};

除非我们得到tpyos：

Cat cat;
Dog dog;
Animal a((const Animal&)cat); //every tutorial teaches us that this is bad!!
a.speak();
a = (const Animal&)dog;
a.speak();

的工作。

我的复制/移动ctors是明智的，我在向量中工作，而且我没有悬挂指针。

我们可以超越对象切片吗？

1 个答案: