我是否可以使用多态性将不同的对象存储在具有C++；？ 我学习C++，我正在尝试做一个小程序。我的应用程序采用以下非正式方式（不含税）： 2 3 Mi_primera_tablet 7.95 1 El_general_en_su_laberinto Gabriel_García_Márquez 23.50

其中第一行是项目数

第二行和第三行=

税种+头衔+无税价格

这些物品可以是不同的类型：书籍（税种3）、玩具（税种1）

所有类型都继承自类文章，但根据税收类型，价格会有所不同（多态性）

---

我需要将所有项（不同类型）存储在一个数组中，如何才能做到这一点？

如果我正确理解了您的问题，您需要知道如何使用基类的派生类定义基类的数组。如果是这种情况，您可以通过在基类中定义一个数组来实现，在您的示例中，该数组如下所示：

article ArrayName [n];
Books Books = new Books();
//do some thing with the books object
ArrayName[0] = Books;

所有类型都继承自类文章，但取决于税 类型价格将不同（多态性）

类型

或

税务类型

可以作为成员存储在

类文章

中

这里不需要多态性

这些物品可以是不同的类型：书籍（税种3）、玩具（税种3） (一)

或者，您可以只存储类型（

书籍

，

玩具

），并在表

类型|税务类型

中进行查找，前提是每种类型的所有税务类型始终相同

---

但是，如果您确实拥有或需要每种类型的派生类（例如存储不同的属性），您可以调用派生类中的虚拟函数

CalcTax（）

可以创建一个带有指向项的（baseclass*）指针的数组，您可以在该数组中循环，并对每个项调用

CalcTax（）

，这将调用正确的虚拟函数

例如：

#include <iostream>

class Base
{
public:
    virtual CalcTax() = 0;
};

class Type_1 : public Base
{
public:
    virtual CalcTax() {std::cout << "Type_1\n";}
};

class Type_2
{
public:
    virtual CalcTax() {std::cout << "Type_2\n";}
};

int main()
{
    Base *arrItems[2]; // or better use std::vector<> etc.
    Type_1 t1;         // just a quick demo of polymorphism
    Type_2 t2;
    arrItems[0] = (Base*)&t1;
    arrItems[1] = (Base*)&t2;

    for (int i = 0; i < 2; ++i) {
        arrItems[i]->CalcTax();
    }

    return 0;
}

#包括
阶级基础
{
公众：
虚拟CalcTax（）=0；
};
类类型_1：公共基
{
公众：
virtual CalcTax（）{std:：cout也许你可以试试boost:：variant library，它可以充当任何东西的包装器。然后你可以在数组中存储许多boost:：variant包装器。你可以在数组中存储指针

示例（c++11）：

我听说你不能做这样的事情，但是你可以在数组中存储指向项的指针。这个问题非常广泛，这个例子也没有很好的动机。也许你应该简单地存储一个
std:：vector
或类似的@MikeCAT提示你的东西。有一些方法可以在连续的存储容器中模拟多态性，但它们可能是在这一点上，我太超前了，我怀疑你的程序是否会出于任何真正的原因需要它。此外，你给出的示例似乎不需要不同的类型。税收类型应该是你的对象的属性，而不是区分类别的原因……当政府决定教科书（仅教科书）是支付不同的税。创建一个全新的类并重新编写所有代码？
#include <iostream>
#include <vector>
#include <memory>

struct A {
  int value;
};


struct B {
  double item;
};


class Element {
 public:
  explicit Element(A a);
  explicit Element(B b);

  const A * AsA() const;
  const B * AsB() const;

 private:
  class AbstractElement {
   public:
    virtual ~AbstractElement() {
    }

   protected:
    AbstractElement() {
    }
  };

  template <typename T>
  struct ConcreteElement : public AbstractElement {
    T body;

    explicit ConcreteElement(T input_body)
        : body(std::move(input_body)) {
    }
  };

  std::unique_ptr<AbstractElement> element_;
};

Element::Element(A a)
    : element_(new ConcreteElement<A>(a)) {
}


Element::Element(B b)
    : element_(new ConcreteElement<B>(b)) {
}


const A * Element::AsA() const {
  const auto concrete_element =
      dynamic_cast<ConcreteElement<A> *>(element_.get());
  return concrete_element ? &(concrete_element->body) : nullptr;
}

const B * Element::AsB() const {
  const auto concrete_element =
      dynamic_cast<ConcreteElement<B> *>(element_.get());
  return concrete_element ? &(concrete_element->body) : nullptr;
}


int main() {
  std::vector<Element> values;
  values.push_back(Element(A{1}));
  values.push_back(Element(B{1.5}));
  values.push_back(Element(A{-5}));
  values.push_back(Element(B{0}));

  for (const auto & element : values) {
    const auto p_a = element.AsA();
    if (p_a) {
      std::cout << "A: " << p_a->value << std::endl;
    } else {
      const auto p_b = element.AsB();
      std::cout << "B: " << p_b->item << std::endl;
    }
  }
  return 0;
}

A: 1
B: 1.5
A: -5
B: 0