Question

假设我们有三个类：A，B，C。A和B都拥有一个指向C类的指针。不应该发生类A的两个实例共享指向对象C的相同指针，但是，同时，对象C可以由B类实例自由指向。

有没有办法在c ++（11）中实现它？

====== EDIT ==

好的，让我们详细介绍一下。当我创建对象C时，我将它们的指针添加到对象B中的容器中。对象A可能拥有或不拥有指向C的指针。重要的是，不超过一个A指向同一个C，这可能是由于用户的错误而实际发生的。一旦A指向C先验，它应该始终指出C的所有生命。

我会选择独特的指针，但我需要将它们复制到B的容器中！

Answer 1

如果将同一指针分配给多个A实例，则听起来好像要抛出异常。

此解决方案可以跟踪使用过的指针以防止重新分配。 它不是线程安全的 ...如果需要，您必须修改它以添加同步。

class A
{
  // The pointers used by all instances of A
  static std::set<C*> used_ptrs;

  // The pointer used by this instance of A
  C* the_c;

  // Sets the pointer if it is valid
  void set_c( C* c )
  {
    if ( the_c )
      throw std::runtime_error( "C pointer is already set in this A" );

    if ( used_ptrs.count( c ) )
      throw std::runtime_error( "C pointer is already set in another A" );

    the_c = c;
    used_ptrs.insert( c );
  }

  // The pointer is presumed to be unassigned at construction
  A() : the_c(NULL) {}

  // The pointer is removed from the set at destruction
  ~A()
  {
    if( the_c );
      used_ptrs.erase( the_c );
  }

  // Copying A is invalid by your description
  A( const A& ) = delete;
  A& operator= ( const A& ) = delete;
}

Answer 2

我认为您需要在班级内部进行一些簿记，可能使用静态unordered_map成员。我已经测试了以下代码：

using namespace std;

struct C;

struct A
{
  void SetPointerToC(C & aC)
  {
    if ( mAllC.find(&aC) != mAllC.end() )
      assert(false); // multiple instances of A should not point to the same C

    mAllC[&aC] = this;
    mC = &aC;
  }

  ~A()
  {
    mAllC.erase(mC);
  }

private:

  // A is not copyable as to prevent multiple A instances having 
  // mC with the same value
  A(const A &);
  A & operator=(const A &);

  static unordered_map<C*, A*> mAllC;
  C * mC;
};

unordered_map<C*, A*> A::mAllC;

struct C
{

};

int _tmain(int argc, _TCHAR* argv[])
{
  A a;    
  A a2;
  C c;
  a.SetPointerToC(c); // works
  a2.SetPointerToC(c); // assert!

  return 0;
}

一个类中的唯一指针

2 个答案: