问题描述

我想知道如何用引用来实现多态，而不是指针.

I was wondering how you can do polymorphism with references, as opposed to pointers.

为了澄清，请参阅以下最小示例:

To clarify, see the following minimal example:

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 所示，我必须将指针转换为引用"；通过取消引用它.

This compiles and works, but as the most important point here is that a in line #1 is a reference, so in order to be able to use it polymorphically (is that an actual word?), as shown in line #3 I have to "convert a pointer to a reference" by dereferencing it.

这让我觉得有点奇怪，我想知道是否有更好的(在更清洁的意义上)方法.只有我吗?

This strikes me as a bit odd, and I was wondering if there is a better (in the sense of cleaner) way. Is it just me?

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

It would be great if I didn't need a new at all, but when declaring (!) B I have no clue how to create an instance of A1 (!) as A is a forward declaration -- A1 is implemented in the same compilation unit as B. Still, is there a real need for dynamic memory allocation in this case? How would you do this?

抱歉让我有点双重问题.

Sorry for the slightly twofold question.

注意:B 很大(我不能为它制作模板类)，并且会在程序终止时精确地超出范围 -- a 很小并使两个大模块相互通信，只要 B 的实例存在(只有一个)，就需要它.

Note: B is huge (and I cannot make a template class of it), and will go out of scope precisely when the program terminates -- a is small and makes two big modules talk to each other, it will be needed as long as the instance of B lives (there is only one).

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

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