A C++ covariance/overriding/circularity problem

Question

I am writing a backend of a compiler of a subset of Java. The backend writes C++ code. There is some hypothetical Java code, though, that I do not known how to translate to C++.

An example problem is shown in the following code. A is extended by B, B is extended by C, and here are respective three header files A.h, B.h and 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) */

As can be seen, B overrides A's method get(). The overriding method returns a pointer to a respective subclass, which I guess is valid in C++, thanks to covariance.

What I do not know, is the way of informing the compiler, that C is indeed a subclass of B, and thus, that the overriding method is valid.

A forward declaration of C within B.h, just as the one seen in the code, is not enough, as it says nothing about C's superclasses.

An inclusion of C.h within B.h would be circular, as C.h already includes B.h. The latter is needed, because it is not enough to have only a forward declaration of the superclass.

What can be done with that?

EDIT Two remarks.

1 One of the poster claims, that the following is impossible in Java, so I add a Java version:

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 {
}

It compiles just fine.

2 I do not insist on compiling such somewhat strange cases. If they can not be translated to a readable code in C++, then fine, the backend will just fail with an error message. In fact, I am more interested in a general way of resolving the circular dependencies like that in C++.

EDIT 2

Thank you all, I am impressed by the efficiency of this site.

I concluded that, because:

1. the header files generated are going to be used by other programmers;
2. guessing from your answers, there is likely no solution that produces simple, readable header files;
3. circular references involving return types are probably rare;
4. I avoid C++ because, amongst others, it allows for solutions like that -- I know C++ has its uses, but personally, I prefer languages that have a simpler grammar, like Java;

the backend will:

1. use forward declarations where possible;
2. otherwise it will use includes, checking if the latter is circular; if yes, it will fail with an error message.

Cheers, Artur

Answer 1

As you're generating code by machine, it's OK to use some dirty, filthy tricks.

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

You can implement covariance yourself, cleanly, without relying on the compiler and without any casts. Here's a header with some circular dependencies:

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();    
};

You implement B::get_A in terms of B::get_C and C::get_A in terms of C::get_B. All get_* are implemented in the cxx file. You can because all three classes are already completely defined. The user always calls get().

Sorry if the formatting is wrong, I'm posting from a cell phone.

Edit: the solution with static casts is not always applicable, e.g. when virtual inheritance is involved (you will need dynamic casts then).

Answer 3

I'm not sure your explanation of the problem's origin (writing a compiler back-end) is truthful, because (1) the presented code is not even correct, lacking semicolons, and I think one who were writing compiler stuff would manage to present correct code, and (2) the problem does not naturally occur in Java code, and I'm not sure it can even be expressed directly in Java except by the workaround that I show below (in which case you would not need to ask), and (3) it's not a difficult problem, not a problem a compiler writer would struggle with.

That is, I strongly suspect that this is homework.

That said, you simply have to implement the covariance yourself, e.g. like this:

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
{};

It's the same as implementing covariant smartpointer results, except that for smartpointer results one can more rely on C++ support for covariant raw pointer results.

It's a well-known technique.

Cheers & hth.,

Answer 4

Serious design issue here.

For the virtual function feature to work, all the get() function in classes A, B and C should have the same signature.

Change everything to:

virtual A* get();

Then

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.

Is this what you want?