C++ 中模板的循环引用，当需要完整类型时

Question

Consider this example in C#:

class C<T> {
   
   void greetMe() { print("Hello you"); }
}

class D : C<E> {
   void useE(E e) {
      e.greetMe();
   }
}

class E : C<D> {
   void useD(D d) {
      d.greetMe();
   }
}

Is an equivalent construction possible in C++ using templates?

I don't have any useful C++ code to show, since my interest in this is purely academic. You can consider this code as pseudocode.

For the curious: I was examining restrictions of eager languages to handle circular references, as opposed to lazy languages. I remembered that something like this is possible in C#'s type system, which I'm attempting to view as a statically checked lazy language. I remembered that C++'s templates are the exact opposite (but still somewhat functional?), which I thought might be an interesting study.
Thank you for your time!

Related question

Answer 1

Extending from Not A Number's answer to the related question and embedding comments where I felt it was necessary:

template <class T>
class C {
public:
   void greetMe() {  }
};

class E; // forward declare E same as answer to related question
class D : public C<E> {
   void useE(E & e); // Passing by reference should be similar to the behaviour 
                     // of the C# program
                     // only declare function. Fully define later after D is complete
};

class E : public C<D> {
   void useD(D & d) { //D is already complete; we can safely define here
      d.greetMe();
   }
};

// now we can define D's implementation of useE 
void D::useE(E & e) {
   e.greetMe();
}

Answer 2

You cannot have a complete type before it is defined, because the definition is what makes the type complete.

There may never be a cycle in the dependency graph.

That said, the class D does not require E to be complete. Only the definition of D::useE depends on that definition. So, following order of definition satisfies all dependencies: D , E , D::useE .

template <class T>
struct C {
   void greetMe();
};

struct E;
struct D : C<E> {
   void useE(E e);
};

struct E : C<D> {
   void useD(D d) {
      d.greetMe();
   }
};

void D::useE(E e) {
    e.greetMe();
};