C++ 协方差/覆盖/循环问题

Question

我正在编写 Java 子集的编译器的后端。后端编写 C++ 代码。不过，有一些假设的 Java 代码，我不知道如何翻译成 C++。

以下代码显示了一个示例问题。 A由B扩展，B由C扩展，下面分别是三个头文件A.h、B.h和C.h：

#ifndef A_H
#define A_H

class B;

class A {
  public: virtual B* get();
}

#endif /* !defined(A_H) */
==========================
#ifndef B_H
#define B_H

#include "A.h"

class C;

class B : public A {
  public: virtual C* get();
}

#endif /* !defined(B_H) */
==========================
#ifndef C_H
#define C_H

#include "B.h"

class C : public B {
}

#endif /* !defined(C_H) */

可以看出，B 覆盖了 A 的方法 get()。重写方法返回一个指向相应子类的指针，我猜这在 C++ 中是有效的，这要归功于协方差。

我不知道的是通知编译器的方式，C 确实是 B 的子类，因此，覆盖方法是有效的。

正如在代码中看到的那样，在 B.h 中对 C 进行前向声明是不够的，因为它没有说明 C 的超类。

在 B.h 中包含 C.h 将是循环的，因为 C.h 已经包含 B.h。后者是必需的，因为只有超类的前向声明是不够的。

可以用它做什么？

编辑两句话。

1 一位发帖人声称，以下内容在 Java 中是不可能的，所以我添加了一个 Java 版本：

A.java：

class A {
  public B get() {
    return null;
  }
}

B.java：

class B extends A {
  public C get() {     
    return null;
  }
}

C.java：

class C extends B {
}

它编译得很好。

2 我不坚持编译这种有些奇怪的案例。如果它们不能被翻译成 C++ 中的可读代码，那么很好，后端将失败并显示错误消息。事实上，我对解决循环依赖的一般方法更感兴趣，比如在 C++ 中。

编辑 2

谢谢大家，这个网站的效率给我留下了深刻的印象。

我的结论是，因为：

1. 生成的头文件将被其他程序员使用；
2. 根据您的回答猜测，可能没有解决方案可以生成简单、可读的头文件；
3. 涉及返回类型的循环引用可能很少见；
4. 我避免使用 C++，因为除其他外，它允许这样的解决方案—— 我知道 C++ 有它的用途，但就我个人而言，我更喜欢语法更简单的语言，比如 Java；

后端将：

1. 尽可能使用前向声明；
2. 否则它将使用包含，检查后者是否是循环的；如果是，它将失败并显示错误消息。

干杯， 阿图尔

Answer 1

当您通过机器生成代码时，可以使用一些肮脏、肮脏的技巧。

class B;

class A {
  public: virtual B* CLASS_A_get();
}

class C;

class B : public A {
  public:
    virtual B* CLASS_A_get();
    virtual C* CLASS_B_get();
}

class C : public B {
}

// In B's .cpp file, you can include C.h
#include "C.h"
B* B::CLASS_A_get() {
    return CLASS_B_get();
}

Answer 2

您可以自己干净利落地实现协方差，无需依赖编译器，也无需任何强制转换。这是一个带有一些循环依赖的标题：

class A
{
  public:
    A* get() { return get_A(); }
  private:
    virtual A* get_A();
};

class B : public A
{
  public:
    C* get() { return get_C(); }
  private:
    virtual A* get_A();
    virtual C* get_C();    
};

class C : public A
{
  public:
    B* get() { return get_B(); }
  private:
    virtual A* get_A();
    virtual B* get_B();    
};

您根据 B::get_C 实现 B::get_A，根据 C::get_B 实现 C::get_A。所有 get_* 都在 cxx 文件中实现。你可以，因为这三个类都已经完全定义好了。用户总是调用 get()。

抱歉，如果格式错误，我是用手机发帖的。

编辑：静态转换的解决方案并不总是适用，例如当涉及到虚拟继承时（你将需要动态转换）。

Answer 3

我不确定您对问题根源的解释（编写编译器后端）是否真实，因为 (1) 提供的代码甚至不正确，缺少分号，我认为编写编译器的人会设法呈现正确的代码，并且（2）问题不会自然发生在 Java 代码中，我不确定它甚至可以直接用 Java 表达，除非我在下面显示了解决方法（在这种情况下，您不需要去问），并且（3）这不是一个难题，也不是编译器编写者会遇到的问题。

也就是说，我强烈怀疑这是家庭作业。

也就是说，您只需自己实现协方差，例如像这样：

class B;

class A
{
private:
    virtual B* virtualGet() { ... }
public:
    B* get() { return virtualGet(); }
};

class C;

class B
    : public A
{
private:
    virtual B* virtualGet() { ... }
public:
    C* get() { return static_cast<C*>( virtualGet() ); }
};

class C
    : public B
{};

这与实现协变智能指针结果相同，除了智能指针结果可以更多地依赖 C++ 对协变原始指针结果的支持。

这是一种众所周知的技术。

干杯，

Answer 4

这里有严重的设计问题。

要使虚函数功能起作用，A、B 和 C 类中的所有 get() 函数都应该具有相同的签名。

将所有内容更改为：

虚拟A* get();

然后

A* ptr1 = new B;
ptr1->get(); // this will call the get function of class B.

A* ptr2 = new C;
ptr2->get(); // this will call the get function of class C.

这是你想要的吗？