C++ 指向类类型的指针

本质上，我试图解决无法将派生类型作为派生类型存储在基类型的（值）数组中的问题。我有多个存储一到三个整数的类，但必须有非常不同的函数集。我会使用一个指针数组，但整个数组都是向前遍历，然后不断向后遍历，基本上是线性的，所以最好将所有指针都保存在内存中。我可以创建多个数组，每种类型一个，然后创建一个指向每种类型的指针数组，但这会很快变得非常笨拙，而且实际上不会像每个元素一样整齐地排列在它前面的元素和在运行时按访问顺序进行访问的元素之间

所以我想的是，我制作一个包含三个int和一个指针的POD结构，并用它们填充一个数组，然后使用该指针访问多态函数。它的结局是这样的：（请原谅这里糟糕的编码，我只是想传达这个概念）

A类{
int aa（&foo f）{return 1；}
int dd（）{return 9；}
};
B类：A{
int aa（&foo f）{return f.b；}
};
丙类：甲{
int aa（&foo f）{return cc（）+f.c-f.a；}
int cc（）{return 4；}
};
D类：B类{
int dd（）{return 7；}
};
结构foo{inta，b，c；a*ptr；}；
常数A AA=A（）；常数B BB=B（）；常数C CC=C（）；常数D DD=D（）；
富[100]富；
init（）{
foo[0]=foo{1,2,3和BB}；
//etc用各种foo元素填充foo
}
bar（）{
对于（int i=0；i<100；++i）{
打印foos[i].ptr.aa（&foos[i]）；
print foos[i].ptr.dd（）；
}
}
main（）{
init（）；
while（true）
bar（）；
}

---

我只是想知道这是实现我想要的目标的最佳方式，还是有更好的解决方案？理想情况下，我只会指向一个类，而不是一个类的实例，但我不认为我真的可以这样做。。。理想情况下，我会将它们存储在一个数组中，作为多个派生类型，但由于明显的原因，这是不可能实现的。

您需要的是虚拟函数

在下面的示例中：

  class A
  {

       virtual void foo(){printf("A is called");};
  }
  class B : public A
  {
         void foo(){printf("B is called");};
  }

  ...
  A* ptr = new B();
  ptr->foo();

将产生“B被称为”

如果不想使用虚拟函数（例如，为了节省内存），可以使用动态强制转换，但这将导致显著的性能损失

请注意，您不需要至少有一个虚拟函数来执行动态强制转换

在下面的示例中：

    class A {...}
    class B : public A {...}
    class C : public A {...}

    A* ptr1 = new C();
    B* ptr2 = dynamic_cast<B*>(ptr1);
    C* ptr3 = dynamic_cast<C*>(ptr1);

---

最后，您可以通过使用自己的类型转换机制来摆脱动态转换，然后将C转换为正确的类。

您需要多态性。在您的示例中，所有类都有标准方法。您需要将它们虚拟化，以便可以应用多态性

class A { 
    virtual int aa( foo& f )const { return 1; }   
    virtual int dd()const { return 9; } 
};
class B : A {
    virtual int aa( foo& f )const { return f.b; } 
};
class C : A {
    virtual int aa( foo& f )const { return cc() + f.c - f.a; }
    int cc()const { return 4; }// this doesn't need to be virtual because is not in the base class A
};
class D : B {
    virtual int dd()const { return 7; } 
};

以下是有关此主题的一些信息：。还有一些关于如何使用指针的信息。 我建议看看智能指针： 你应该看的另一个主题是constness：搜索“constness c++”（不能发布超过2个链接）

。。。我试图解决无法将派生类型作为派生类型存储在基类型的（值）数组中的问题

您可以将派生类型作为值存储在数组中，但不能将它们存储为基类型的实例

具体叶类型的

union

几乎就是您想要的，但是无法确定union的哪个成员是活动的，也无法使用多态分派

一个有歧视的工会会告诉你哪个会员是活的，但不会直接帮助派遣

---

是一个特定的有区别的联合，它为多态调度提供了一个干净的机制-不使用

virtual

，而是使用对每个具体存储类型具有重载的访问者。在这种情况下，您甚至不需要将存储的类型与公共抽象基相关联——它们可以是完全不相关的。请在中查找

apply\u visitor

以了解详细信息。

除了从未遇到过它们之外，还有什么原因不能只使用歧视性的联合，比如Boost.Variant？我不确定。如果在每个函数中都没有一堆笨拙的switch语句，我如何在保留相同类型的同时生成一个多态性呢？好的，只是检查一下您是否知道它们并排除了它们。它们应该做你需要的事情，用vision而不是switch语句。虚拟函数对内存有什么影响？如果我只初始化了每个类的一个实例，并且有几个指针指向这些类中的每一个，这将产生与我有每个类的几个实例相同的影响（前提是以相同的速率访问函数）？我真的不想显式强制转换任何内容，也不想手动计算类型（如果可以避免），因为我希望尽可能快地在数组中移动…然后在对象中使用虚拟函数或函子数组，您应该会很好。感谢链接！这是一个指向a的常量指针，还是一个指向常量a的指针？在这里你可以得到一些信息：它是指向常量a的指针。

     if (ptr2)
     {
        ptr2->bb();
     } else if (ptr3)
     {
        ptr3->cc();
     }

class A { 
    virtual int aa( foo& f )const { return 1; }   
    virtual int dd()const { return 9; } 
};
class B : A {
    virtual int aa( foo& f )const { return f.b; } 
};
class C : A {
    virtual int aa( foo& f )const { return cc() + f.c - f.a; }
    int cc()const { return 4; }// this doesn't need to be virtual because is not in the base class A
};
class D : B {
    virtual int dd()const { return 7; } 
};

struct foo{ int a, b, c;const A* ptr; }; // const A* instead of A*