我遇到了C++ FAQ基类的有趣实现，根据我天真的理解，它可以作为一些智能指针实现的替代（例如shared_ptr）。这里是逐字的示例代码，但请按照上面的链接获取解释：
class Fred {
public:
static Fred create1(std::string const& s, int i);
static Fred create2(float x, float y);
Fred(Fred const& f);
Fred& operator= (Fred const& f);
~Fred();
void sampleInspectorMethod() const; // No changes to this object
void sampleMutatorMethod(); // Change this object
...
private:
class Data {
public:
Data() : count_(1) { }
Data(Data const& d) : count_(1) { } // Do NOT copy the 'count_' member!
Data& operator= (Data const&) { return *this; } // Do NOT copy the 'count_' member!
virtual ~Data() { assert(count_ == 0); } // A virtual destructor
virtual Data* clone() const = 0; // A virtual constructor
virtual void sampleInspectorMethod() const = 0; // A pure virtual function
virtual void sampleMutatorMethod() = 0;
private:
unsigned count_; // count_ doesn't need to be protected
friend class Fred; // Allow Fred to access count_
};
class Der1 : public Data {
public:
Der1(std::string const& s, int i);
virtual void sampleInspectorMethod() const;
virtual void sampleMutatorMethod();
virtual Data* clone() const;
...
};
class Der2 : public Data {
public:
Der2(float x, float y);
virtual void sampleInspectorMethod() const;
virtual void sampleMutatorMethod();
virtual Data* clone() const;
...
};
Fred(Data* data);
// Creates a Fred smart-reference that owns *data
// It is private to force users to use a createXXX() method
// Requirement: data must not be NULL
Data* data_; // Invariant: data_ is never NULL
};
Fred::Fred(Data* data) : data_(data) { assert(data != NULL); }
Fred Fred::create1(std::string const& s, int i) { return Fred(new Der1(s, i)); }
Fred Fred::create2(float x, float y) { return Fred(new Der2(x, y)); }
Fred::Data* Fred::Der1::clone() const { return new Der1(*this); }
Fred::Data* Fred::Der2::clone() const { return new Der2(*this); }
Fred::Fred(Fred const& f)
: data_(f.data_)
{
++data_->count_;
}
Fred& Fred::operator= (Fred const& f)
{
// DO NOT CHANGE THE ORDER OF THESE STATEMENTS!
// (This order properly handles self-assignment)
// (This order also properly handles recursion, e.g., if a Fred::Data contains Freds)
Data* const old = data_;
data_ = f.data_;
++data_->count_;
if (--old->count_ == 0) delete old;
return *this;
}
Fred::~Fred()
{
if (--data_->count_ == 0) delete data_;
}
void Fred::sampleInspectorMethod() const
{
// This method promises ("const") not to change anything in *data_
// Therefore we simply "pass the method through" to *data_:
data_->sampleInspectorMethod();
}
void Fred::sampleMutatorMethod()
{
// This method might need to change things in *data_
// Thus it first checks if this is the only pointer to *data_
if (data_->count_ > 1) {
Data* d = data_->clone(); // The Virtual Constructor Idiom
--data_->count_;
data_ = d;
}
assert(data_->count_ == 1);
// Now we "pass the method through" to *data_:
data_->sampleMutatorMethod();
}
我没有看到这种方法在任何C ++库中使用;虽然看起来很优雅。假设单线程环境，为简单起见，请回答以下问题：
答案 0 :(得分：7)
这是用于管理对象生命周期的智能指针方法的合适替代方法，还是仅仅是在寻找麻烦？
不，我认为重新引用引用计数并不是一个好主意，因为我们现在已经在C ++ 11中使用了std :: shared_ptr。您可以根据std :: shared_ptr轻松实现可能的多态引用计数Pimpl习语类。注意我们不再需要实现复制ctor，赋值，dtor，而且变异变得更简单了w.r.t.参考计数器和克隆：
// to be placed into a header file ...
#include <memory>
#include <utility>
#include <string>
class Fred
{
public:
static Fred create1(std::string const& s, int i);
static Fred create2(float x, float y);
void sampleInspectorMethod() const; // No changes to this object
void sampleMutatorMethod(); // Change this object
private:
class Data;
std::shared_ptr<Data> data_;
explicit Fred(std::shared_ptr<Data> d) : data_(std::move(d)) {}
};
......以及实施......
// to be placed in the corresponding CPP file ...
#include <cassert>
#include "Fred.hpp"
using std::shared_ptr;
class Fred::Data
{
public:
virtual ~Data() {} // A virtual destructor
virtual shared_ptr<Data> clone() const = 0; // A virtual constructor
virtual void sampleInspectorMethod() const = 0; // A pure virtual function
virtual void sampleMutatorMethod() = 0;
};
namespace {
class Der1 : public Fred::Data
{
public:
Der1(std::string const& s, int i);
virtual void sampleInspectorMethod() const;
virtual void sampleMutatorMethod();
virtual shared_ptr<Data> clone() const;
...
};
// insert Der1 function definitions here
class Der2 : public Data
{
public:
Der2(float x, float y);
virtual void sampleInspectorMethod() const;
virtual void sampleMutatorMethod();
virtual shared_ptr<Data> clone() const;
...
};
// insert Der2 function definitions here
} // unnamed namespace
Fred Fred::create1(std::string const& s, int i)
{
return Fred(std::make_shared<Der1>(s,i));
}
Fred Fred::create2(float x, float y)
{
return Fred(std::make_shared<Der2>(x,y));
}
void Fred::sampleInspectorMethod() const
{
// This method promises ("const") not to change anything in *data_
// Therefore we simply "pass the method through" to *data_:
data_->sampleInspectorMethod();
}
void Fred::sampleMutatorMethod()
{
// This method might need to change things in *data_
// Thus it first checks if this is the only pointer to *data_
if (!data_.unique()) data_ = data_->clone();
assert(data_.unique());
// Now we "pass the method through" to *data_:
data_->sampleMutatorMethod();
}
（未测试的）
如果它合适，为什么你认为它不经常使用？
我认为引用计数，如果你自己实现，更容易出错。它还具有在多线程环境中速度慢的声誉，因为引用计数器必须以原子方式递增和递减。但我想由于C ++ 11提供了shared_ptr和移动语义，这种写时复制模式可能会再次受欢迎。如果为Fred类启用移动语义，则可以避免以原子方式递增引用计数器的一些成本。因此将Fred对象从一个位置移动到另一个位置应该比复制它更快。
答案 1 :(得分：4)
这是用于管理对象生命周期的智能指针方法的合适替代方法，还是仅仅是在寻找麻烦？
这是另一种选择，但除非你有充分的理由使用它，否则它只是重新发明轮子（以不可重复使用的方式）。
如果您将代码更改为使用shared_ptr，则您将无需显式定义复制/所有权语义（并在您的pimpl基础中定义复制构造函数和赋值）。您还将使用已经定义和测试的代码（因为它是库的一部分）。
如果它合适，为什么你认为它不经常使用？
因为shared_ptr可用并且已经实现了功能和所有“问题”。
答案 2 :(得分：3)
我也是，我想知道它是否适合作为智能指针的替代品。
但是，IMO要成为一个智能指针，一个类必须可用作指针，即：
SmartPtr<int> ptr = new int(42);
int x = *ptr;
是的，它是一种内存管理，但它不是一个智能指针，因为它没有指针的语义。
正如评论中所提到的，pimpl习惯用法对于保持兼容性非常有用，它还可以促进开发，因为您不必重新编译包含类。 但是要具有后一个优点，你不能在父类内部定义内部类（即数据），而只是放置一个前向声明并将实际定义放在另一个头中。
class Fred {
...
private:
class Data;
};
并且，我发现在Fred类中声明Data的变体对于将来的开发没有用，因为如果你需要添加另一个类，你需要修改Fred而不是仅创建另一个类。这可能是想要的，但我建议你避免这一部分。
如果我不清楚某事，请随时提问！
答案 3 :(得分：3)
C ++ FAQ的答案似乎更像是一个简单的例子来管理共享数据（使用copy on write）。有几个方面缺失，这可能很重要。
N / A我对1的看法。
为了避免与std::shared_ptr一样使用“外部”引用计数引入的开销，您可以使用Andrei Alexandrescu's book Modern C++ Design中所述的侵入式引用计数机制。 Loki::COMRefCounted类显示如何为Windows共享COM对象实现此类所有权策略。
本质上，它归结为智能指针模板类接受一个接口，该接口管理引用计数并检查指针类实例本身中的delete可用性。我不知道STD C ++库是否支持为std::shared_ptr类实现此类策略覆盖。
我们在许多嵌入式项目中仅将Loki Library用于智能指针模型非常成功。特别是因为这个功能可以模拟精细粒度方面的效率。
注意默认情况下，建议的（内置）实现不是线程安全的。
如果上述所有方面都不涉及您的目的，我建议您对std::shared_ptr课程进行简单的Fred::Data陈述，如sellibitze的答案所示。我也同意他在最后一段中提出的观点，引用计数和智能指针语义很容易被误解和实现错误。
如果C ++ 11标准或boost不是您的选择，那么loki库仍然提供易于集成和强大的智能指针实现。