您需要做的就是声明 RB 而不使用 : public RA（哦，还要在类定义的末尾添加 ;）：
class RA;
class A {
public:
virtual RA* Foo();
};
class RB;
class B {
public:
virtual RB* Foo();
};
// client includes somewhere.h
class RA {};
class RB : public RA {};
int main ()
{
return 0;
}
但是，这并不能解决 user1332054 的回答中很好地描述的具体问题。
其他一些答案似乎表明了我想消除的一些误解：
当我们知道定义不太可能被包含时，向前声明是有用的甚至。这允许我们在我们的库中进行大量类型推断，使它们与许多其他已建立的库兼容，而不包括它们。包含不必要的库会导致过多的嵌套包含，这可能会增加编译时间。最好在适当的时候使您的代码兼容，并尽可能少地包含。
通常，您可以定义一个带有指向仅已声明但未定义的类的指针的类。示例：
struct B;
struct A
{
B * b_;
B * foo ()
{
return b_;
}
B & foo (B * b)
{
return *b;
}
};
int main ()
{
return 0;
}
上面的编译很好，因为编译器不需要知道关于 B 的任何信息。
一个可能有点难以意识到编译器需要更多信息的例子：
struct B;
struct A
{
B * foo ()
{
return new B;
}
};
上述问题是因为new B调用了尚未定义的B::B()构造函数。另外：
struct B;
struct A
{
void foo (B b) {}
};
这里foo 必须调用b 的复制构造函数，它还没有被定义。最后：
struct B;
struct A
{
B b;
};
这里我们用默认构造函数隐式定义了A，它调用了调用其成员的默认构造函数b，尚未定义。我想'你明白了。
所以，关于 user1332054 描述的更普遍的问题，老实说，我不明白为什么不能在继承的虚函数中使用指向未定义类的指针。
但更广泛地说，我认为您通过定义您的类而不是仅仅声明它们使自己变得更加困难。这是一个示例，在您完全定义任何类之前，您可以使用库中的类到达 DoCleverStuff：
// Just declare
class RA;
class RB;
class A;
class B;
// We'll need some type_traits, so we'll define them:
template <class T>
struct is_type_A
{
static constexpr bool value = false;
};
template <>
struct is_type_A <A>
{
static constexpr bool value = true;
};
template <class T>
struct is_type_B
{
static constexpr bool value = false;
};
template <>
struct is_type_B <B>
{
static constexpr bool value = true;
};
#include <type_traits>
// With forward declarations, templates and type_traits now we don't
// need the class definitions to prepare useful code:
template<class T>
typename std::enable_if<is_type_A<T>::value, RA *>::type
DoCleverStuff (T & t)
{
// specific to A
return t.fooRet();
}
template<class T>
typename std::enable_if<is_type_B<T>::value, RB *>::type
DoCleverStuff (T & t)
{
// specific to B
return t.fooRet();
}
// At some point the user *does* the include:
class RA
{
int x;
};
class RB : public RA
{
int y;
};
class A
{
public:
virtual RA * fooRet()
{
return new RA;
}
};
class B : public A
{
public:
virtual RB * fooRet()
{
return new RB;
}
};
int main ()
{
// example calls:
A a;
RA * ra = DoCleverStuff(a);
B b;
RB * rb = DoCleverStuff(b);
delete ra;
delete rb;
return 0;
}