c++ - 这是对私有(private)构造函数的良好使用吗？

Question

我每天都在努力学习新东西，我会对以下设计的好坏感兴趣。

我正在实现一个类 A将自身的对象缓存在静态私有(private)成员变量中 std::map<> cache . A的用户应该只能访问指向 map 中元素的指针，因为 A 的完整拷贝很贵而且不需要。一个新的A仅在 map 中尚不可用时创建，作为 A 的构造需要一些繁重的工作。好的，这是一些代码:

class B;

class A {
    public:
        static A* get_instance(const B & b, int x) {
            int hash = A::hash(b,x);
            map<int, A>::iterator found = cache.find(hash);
            if(found == cache.end())
                found = cache.insert(make_pair(hash, A(b,x))).first;
            return &(found->second);
        }
        static int hash(B & b, int x) { 
            // unique hash function for combination of b and x
        }
        // ...

    private:
        A(B & b, int x) : _b(b), _x(x) { 
            // do some heavy computation, store plenty of results 
            // in private members
        }
        static map<int, A> cache;
        B _b;
        int _x; // added, so A::hash() makes sense (instead of B::hash())
        // ...
 };

上面的代码有什么问题吗？有没有陷阱，我是否想念内存管理问题或其他问题？

感谢您的反馈!

Answer 1

该实现旨在仅允许您通过 get_instance() 创建项目。理想情况下，您应该将复制构造函数和赋值运算符设为私有(private)。

它不是线程安全的。您可以改用以下内容:

const boost::once_flag BOOST_ONCE_INIT_CONST = BOOST_ONCE_INIT;

struct AControl
{
  boost::once_flag onceFlag;
  shared_ptr<A> aInst;

  void create( const B&b, int x )
  {
      aInst.reset( new A(b, x) );
  }

  AControl() : onceFlag( BOOST_ONCE_INIT_CONST )
  {
  }

  A& get( const B&b, int x )
  {
     boost::call_once( onceFlag, bind( &AOnceControl::create, this, b, x ) );
     return *aInst;
  }
};

将 map 更改为 map

有一个互斥锁并这样使用它:

AControl * ctrl;
{
  mutex::scoped_lock lock(mtx);
  ctrl = &cache[hash];
}
return ctrl->get(b,x);

理想情况下，只有 get_instance() 在您的类中是静态的。其他一切都是私有(private)实现细节，并进入您的类的编译单元，包括 AControl。

请注意，您可以通过在 map 中查找和创建的整个过程中锁定来更简单地完成此操作，但是在进行漫长的构建过程时，您将锁定更长时间。因为它是在您插入项目后实现记录级锁定。稍后的线程可能会发现该项目未初始化，但 boost::once 逻辑将确保它只创建一次。