模板参数中的自引用模板

我该怎么做才能使这项工作成功：

template<class C, class V, Test V::*>
class Test {
};

它给了我编译器错误：

unknown type name 'Test'

目前它是一个自引用模板，这似乎不可能。可以采取什么措施才能使其发挥作用？

EDIT:

这就是我需要这个的目的。我想以最少的编码工作实现双向（认为父子）关系模式。

template <class O, class T, Reference<T, O, Reference O::*> T::* opposite>
class Reference
{
    T **data;
    int count;
public:
    Reference(): data(new T*[N]), count(0) {}
    ~Reference() {delete[] data;}
    Reference &add(T *t) {
        handleOtherSide();
        return link(t);
    }
    // a lot of stuff to implement this
};

这就是集合类。下面是它的使用方法：

class Partner
{
public:
    Reference<Partner, Address, &Address::partner> addresses;
};

class Address
{
public:
    Reference<Address, Partner, &Partner::addresses> partner;
};

我的目标是将 Reference 工作所需的一切都作为模板参数提供，这样就不需要为 Partner 和 Address 等类提供构造函数（目前我提供相反的成员指针作为构造函数参数，但这要求我有参与者类的显式构造函数）。我还需要传入或计算指向 Reference 类的“所有者”指针。我将这个问题留在这里，因为我想重点讨论自引用模板方面。

想到这一点的最简单方法是 boost::bimap。但 bimap 的问题是我不想要封闭的 bimap，而只想要它的左右部分。 bimap 也是不可行的，因为它会导致单个 bimap 管理特定关系的所有关联。它可能会容纳大量对象，从而减慢其操作速度。

您在寻找这样的东西吗？它不是自引用模板，但您可以指定派生类作为基类的模板类型，并且基类可以调用派生方法等：

template< typename PType, typename PDerived >
class TBase
{
  //do stuff with TDerived
 public:
  bool foo( void )
  {
   return ( static_cast< PDerived* > ( this )->bar() );
  }
};

template< typename PType >
class TDerived : public TBase< PType, TDerived< PType > >
{
  friend class TBase< PType, TDerived< PType > > ;
  //do stuff
 protected:
  bool bar( void )
  {
   return ( true );
  }
};

编辑：我再次不确定你的最终目标是什么。这是我认为您想要的解决方案，或者至少是您可以用来实现设计的一些提示。我提出的唯一要求是TAddress and TPartner具有同名函数。看看这是否是您所需要的。原则上，您可以创建一个辅助类并使用 CRTP 通过指针访问成员函数，但我认为您实际上并不需要它。

template< typename PType1, typename PType2 >
class TReference
{
 public:
  int mFlag;

  TReference() :
   mFlag( 0 )
  {
  }
  TReference( int fFlag ) :
   mFlag( fFlag )
  {
   std::cout << "Creating reference " << PType1::sName << " -> " << PType2::sName << "." << std::endl;
  }
  TReference< PType2, PType1 > AccessOpposite( void )
  {
   PType2 lTmp;
   lTmp.Opposite();

   return TReference< PType2, PType1 > ( -1 );
  }
};

class TPartner;

class TAddress
{
 public:
  static const char* sName;
  TReference< TAddress, TPartner > mRef;

  void Opposite( void )
  {
   std::cout << sName << "::Opposite" << std::endl;
  }
};

class TPartner
{
 public:
  static const char* sName;
  TReference< TPartner, TAddress > mRef;

  TReference< TAddress, TPartner > Opposite( void )
  {
   std::cout << sName << "::Opposite" << std::endl;
  }
};

const char* TAddress::sName = "TAddress";
const char* TPartner::sName = "TPartner";

int main( void )
{
 TAddress lAddress;
 TPartner lPartner;

 std::cout << lAddress.mRef.mFlag << " " << lPartner.mRef.mFlag << std::endl;

 lPartner.mRef = lAddress.mRef.AccessOpposite();

 std::cout << lAddress.mRef.mFlag << " " << lPartner.mRef.mFlag << std::endl;

 return ( 0 );
}