多态 C++ 参考

polymorphic C++ references(多态 C++ 参考)

问题描述

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

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.

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

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?

抱歉，有点双重问题.

注意: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