C++没有指针的多态性

Question

编辑：一个更好的标题是：没有单独堆分配的大型对象集合的多态性。

假设我有一个带有虚函数的基类 Animal 和一些派生类（Cat、Dog 等）。真正的派生类包含 4-8 个字节的数据。我想存储一个 std::list 它实际上包含派生对象的项目。我想避免使用 new 在堆上创建许多小对象。

是否有任何设计模式可以用来实现这一目标？

编辑：我的想法来实现这个

1. 创建 std::deque, std::deque, ...;存储 std::list，其中包含来自 deques 的指针；我使用 std::deque 是因为我认为它对对象块有良好的内存管理；

Answer 1

最终，没有。

多态性仅适用于非值类型：引用和指针。由于引用只能绑定一次，因此您无法真正在标准容器中使用它们。这给你留下了指示。

你在错误的方向上解决问题。如果您担心分配大量小对象的开销（我假设这是一个合理的担忧。也就是说，您有实际的分析数据或足够的经验来知道这是一个问题对于您的特定应用程序），那么您应该修复该。更改为这些对象分配内存的方式。制作一个小的分配堆或其他东西。

诚然，C++0x 之前版本的分配器在这方面有些欠缺，因为它们必须是无状态的。但就您的目的而言，您应该能够处理它。

---

根据您的编辑：

这是一个糟糕的想法。从 任何地方 处的 std::deque 擦除，但开始或结束将使 std::list 中的每个指针无效code>.

鉴于您的评论，这个想法是可行的。然而，为不同类型的对象提供所有这些不同的内存块似乎违背了继承的全部要点。毕竟，您不能只编写一个新的 Animal 类型并将其放入 std::list 中；你必须为其提供内存管理。

您确定您需要的是基于继承的多态性吗？您确定其他方法不会同样有效吗？

Answer 2

我意识到这个问题已经很老了，但我找到了一个相当不错的解决方案。

假设：

您提前知道所有派生类（根据您的编辑，这是正确的）。

技巧：

使用 boost::variant ( http://www.boost.org/doc/libs/1_57_0/doc/html/variant.html)

示例类：

class Animal {
public:
    virtual void eat() = 0;
};

class Cat : public Animal {
    virtual void eat() final override {
        std::cout << "Mmh, tasty fish!" << std::endl;
    }
};

class Dog: public Animal {
    virtual void eat() final override {
        std::cout << "Mmh, tasty bone!" << std::endl;
    }
};

示例变体/访问者：

typedef boost::variant<Cat, Dog> AnimalVariant;

class AnimalVisitor : public boost::static_visitor<Animal&> {
public:
    Animal& operator()(Cat& a) const {
        return a;
    }

    Animal& operator()(Dog& a) const {
        return a;
    }
};

示例用法：

std::vector<AnimalVariant> list;
list.push_back(Dog());
list.emplace_back(Cat());

for(int i = 0; i < 5; i++) {
    for(auto& v : list) {
        Animal& a = v.apply_visitor(AnimalVisitor());
        a.eat();
    }
}

示例输出

Mmh, tasty bone!
Mmh, tasty fish!
Mmh, tasty bone!
Mmh, tasty fish!
Mmh, tasty bone!
Mmh, tasty fish!
Mmh, tasty bone!
Mmh, tasty fish!
Mmh, tasty bone!
Mmh, tasty fish!

Answer 3

如果您担心分配许多小堆对象，那么向量可能是比列表和双端队列更好的容器选择。每次将对象插入列表时，列表都会在堆上分配一个节点，而向量会将所有对象存储在堆上的连续内存区域中。

如果有：

std::vector<Dog> dogs;
std::vector<Cat> cats;

std::vector<Animal*> animals;

void addDog(Dog& dog, std::vector<Dog>& dogs, std::vector<Animal*>& animals) {
  dogs.push_back(dog);
  animals.push_back(&dog);
}

那么所有的狗和猫都存储在堆上两个连续的内存区域中。

Answer 4

这是对使用变体（无论是 Boost 的还是来自 cxx17 以来的 STL 的变体）的建议的后续，如果所有可能的子类在编译时都已知（这种情况也称为“闭集多态性”） ”）。

必须使用访问者模式来访问对象的接口有点烦人（imo），这就是为什么我编写了一个公开基类接口（甚至基类型运算符）的变体类型。可以在以下位置找到：
https://github.com/Krzmbrzl/polymorphic_variant（需要 C++17，因为它是围绕std::variant）。

从 @Draziv 克隆示例：

类定义 示例

class Animal {
public:
    virtual void eat() = 0;
};

class Cat : public Animal {
    virtual void eat() final override {
        std::cout << "Mmh, tasty fish!" << std::endl;
    }
};

class Dog: public Animal {
    virtual void eat() final override {
        std::cout << "Mmh, tasty bone!" << std::endl;
    }
};

用法

pv::polymorphic_variant< Animal, Dog, Cat > variant;
variant->eat();

variant = Cat{};
variant->eat();

输出：

Mmh, tasty bone!
Mmh, tasty fish!

Answer 5

您可能可以使用一个简单的包装类来为包含每种情况所需的数据超集的联合做一些事情。这将包含一个指向共享策略对象的指针，其中包含不同行为的代码。因此，猫是 PolyAnimal 类的对象，其speciesName = "cat"、PredatorFeedingStrategy 等等。

解决根本问题的更好方法可能是设置适当的自定义分配器以获得更自然的设计。