c++ - 模板参数中的自引用模板

Question

我能做些什么来完成这项工作:

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

它给我编译器错误:

unknown type name 'Test'

目前是自引用模板，貌似不太可能。可以做些什么来让它发挥作用？

编辑:

这就是我需要它的原因。我想用最少的编码工作实现双向(想想父子)关系模式。

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 等类提供构造函数(目前我提供相反的成员指针作为构造函数 arg，但这需要我有参与者类的显式构造函数)。我还需要传入或计算指向引用类的“所有者”指针。我把这个问题留在这里是因为我想专注于自引用模板方面。

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

Answer 1

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

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