多态性 C++参考

Question

我想知道如何使用引用而不是指针来实现多态性。

为了澄清这一点，请参阅以下最小示例：

class A;

class B {
  public:
    A& a; ///////////////// <- #1
    B();
    void doStuff();
};

class A {
  public:
    virtual void doSmth() = 0;
};
void B::doStuff() {
  a.doSmth();
}

class A1 : public A {
  public:
    void doSmth() {
    }
};

B::B() : a(
    *        ////////////// <- #2
      (new A1)  /////////// <- #3
     ) {
}

这可以编译并运行，但这里最重要的一点是 #1 行中的 a 是一个引用，因此为了能够多态地使用它（这是一个实际的单词吗？），如第 #3 行所示，我必须通过取消引用它来“将指针转换为引用”。

这让我觉得有点奇怪，我想知道是否有更好的（在更干净的意义上）方式。只有我吗？

基本原理

如果我根本不需要 new 那就太好了，但是当声明 (!) B 时，我不知道如何创建 的实例A1 (!) 因为 A 是一个前向声明 - A1 是在与 B 相同的编译单元中实现的。不过，在这种情况下是否真的需要动态内存分配？你会怎么做？

抱歉这个有点双重的问题。

编辑

注意： B 很大（我无法创建它的模板类），并且当程序终止时将精确地超出范围 - a 很小并且使得两个大模块相互通信，只要 B 实例存在（只有一个），就需要它。

编辑2

我刚刚意识到，由于 A 和 B 实际上都是单例，我可以简单地创建 A1< 的 static 实例/code> 在 B 的编译单元中，避免动态内存分配（即使有两个 B，它们也可以轻松使用 A 的同一个实例代码>）。公平地说，我没有将此作为答案发布，但会接受促使我提出此解决方案的答案。解决方案。

Answer 1

这确实有点奇怪。如果您想要 A1 类型的成员变量（而不是引用），为什么不重新排列代码，使 A1 的定义出现在 的定义之前>B？

Answer 2

不过，这里确实需要动态内存分配吗？
案例？

不需要。只需先定义 A1，然后使其成为 B 的普通成员。

多态性对于引用和指针都可以很好地工作。

Answer 3

不难想象为什么引用可以像指针一样多态地工作（更不用说引用通常被实现为指针）。这是一个简单的示例：

class Base { 
public:
    virtual void something() { }
};

class Derived : public Base {
public:
    void something() { }
};

Base& foo() {
    static Derived d;
    return d;
}

foo().something(); // calls Derived's something

另外，为什么要为引用分配动态内存？在这种情况下，您可能根本不应该使用引用。另外，用参考成员编写类可以有效地防止分配（正如我听到有人说得很好）。

Answer 4

呃，这还不够吗？

#include <iostream>

struct A;

struct B
{
  B(A& a);

  void foo();

  A& _a;
};

struct A
{
  virtual void foo() =0;
};

struct A1 : public A
{
  virtual void foo() { std::cout << "A1::foo" << std::endl; }
};

B::B(A& a) : _a(a) {}
void B::foo() { _a.foo(); }


int main(void)
{ 
  A1 a;  // instance of A1
  B b(a); // construct B with it

  b.foo();
}

Answer 5

不过，在这种情况下是否真的需要动态内存分配？

动态内存分配或将引用注入 B 的 ctor 中。

Answer 6

我意识到这是一篇非常旧的帖子，但还有另一种选择可以处理动态分配对象的引用。您可以分配对动态分配的对象的引用。下面是一些虚拟代码，可让您了解其工作原理。

struct A
{
  int b;
  virtual void print();
  A(int val):b(val) {}
};

struct A_child:public A
{
  A_child(int val):A(val) {}
  void print();
};

void A:print()
{
cout<<"parent\n";
}

void A_child:print()
{
cout<<"child\n";
}

struct test_ref
{
A *& ref;
test_ref(A * ptr) : ref(ptr)
}

int main()
{

  test_ref parent(new A(12));
  parent.ref->print();

  test_ref child(new A_child(15));
  child.ref->print();
} 

老实说，我不确定这什么时候是个好主意。我只是想展示一种替代方法，在初始化对象时不必取消引用动态分配的内存。

我也非常确定在初始化一个类（其中指针存储为引用指针）时动态分配指针可能会导致内存泄漏，除非您可以删除引用指针。

Answer 7

没有什么奇怪的。多态性适用于指针和引用：

struct Base { };
struct Derived : Base;

void foo(Base &);

int main() {
  Derived x;
  foo(x);    // fine
}

您将其与另一个问题混为一谈，即创建对动态对象的引用：

T * pt = new T;
T & rt = *pt;

T & x = *new T;  // same effect

请注意，仅跟踪动态对象通常是非常糟糕的风格< /em> 通过引用，因为删除它的唯一方法是通过 delete &x;，并且很难看出 x 需要清理。

您的设计有两种直接替代方案：1) 将 a 设为 B 中的成员对象，或 2) 将 a 设为 shared_ptr< ;A> 或 unique_ptr 并将初始化器更改为 a(new A1)。这完全取决于您是否确实需要多态行为，即您是否有其他 B 构造函数，这些构造函数将不同的派生类分配给 a 而不是 A1.