C++博客-eXile 的专栏-随笔分类-STL/BOOST

说说C++智能指针(2): 标准库中的智能指针

eXile — Mon, 16 Nov 2009 05:57:00 GMT

使用智能指针是C++中常用的管理内存的方式。关于智能指针的设计，各路C++高手也是各展神通。

在1994年. Greg Colvin向C++标准委员会提出了自己设计的智能指针：auto_ptr和counted_ptr。auto_ptr实现基本的RAII管理，不可复制；counted_ptr采用引用计数实现了一个可复制的智能指针。两者用于不同的场合。
但是标准委员会最终只通过了auto_ptr，并且对auto_ptr加入了一个古怪的“所有权转移”语义。后来auto_ptr和counted_ptr进入了Boost C++ 库，改名为scoped_ptr和shared_ptr。

std::auto_ptr只所以设计为可拷贝的，也许是出于以下考虑，比如下例函数：

void f1(object* ptr);
object* f2();

f1中的参数所指向的对象应该由谁来删除呢？调用者还是被调用者？如果不看程序文档的话，无法知道这一点。f2函数也存在同样的问题。

用auto_ptr可以消除这种歧义性：

void f1(auto_ptr<object> ptr);
auto_ptr<object> f2();

      尽管如此，auto_ptr的“所有权转移”语义还是会带来副作用，因为会修改原值的常量拷贝违背了一般的设计原则，它也许会在你意想不到的情况下就把对象转移了。它也不能用于标准容器中。
   所以auto_ptr在新的标准库已经不再推荐使用。取而代之的是unique_ptr。unique_ptr与auto_ptr类似，但限制了auto_ptr的拷贝行为。同时，像上面举的例子一样，unique_ptr可以作为函数的参数和返回值使用。这是因为C++增加了一个新的特征：右值引用。

   shared_ptr也进入了标准库。对于引用计数的智能指针而言，循环引用是一个大问题。标准库为此把shared_ptr定义为强引用指针，它还实现了一个弱引用指针weak_ptr。显然，标准库并没有从根本上解决循环引用的问题，它把这个问题交给了程序员。在一个简单的系统中，你可以区分使用shared_ptr和weak_ptr，以此来避免出现循环引用。但是在一个大的对象系统中，有时还是容易出错。循环引用的问题，严重减弱了shared_ptr的可用性。

   那么能不能自动检测是否出现循环引用呢？事实上，对于shared_ptr这种使用非侵入式策略实现的智能指针，是很难实现自动检测的。但是如果采用侵入式设计，我们可以引入一些接口，来解决这个问题。循环引用的检测，实际上是图论中的回路检测问题。

      本文由eXile 原创，转载请表明原贴地址。 http://www.cppblog.com/eXile/。

eXile 2009-11-16 13:57 发表评论

boost::asio示例HTTP Server类图

eXile — Tue, 06 May 2008 16:50:00 GMT

eXile 2008-05-07 00:50 发表评论

vector的有序化操作

eXile — Tue, 29 Jan 2008 05:13:00 GMT

　　在有些情况下，需要用到一个有序的vector。它的有序操作有三种：查找，插入，删除。
　　
　　插入实现：

template <typename Container>
inline void ordered_insert(Container& c,　 typename Container::value_type const& t)
{
c.insert(std::upper_bound(c.begin(), c.end(), t), t);
}

template <typename Container, typename Cmp>
inline void ordered_insert(Container& c,　typename Container::value_type const& t,　Cmp cmp)
{
c.insert(std::upper_bound(c.begin(), c.end(), t, cmp), t);
}

　　
　　删除实现：

template <typename Container, typename It>
inline void erase_range(Container& c, std::pair<It, It> const& r)
{
    c.erase(r.first, r.second);
}

template <typename Container>
inline void ordered_erase(Container& c, 　typename Container::value_type const& t)
{
    erase_range(c, std::equal_range(c.begin(), c.end(), t));
}

template <typename Container, typename T, typename Cmp>
inline void ordered_erase(Container& c, T const& t, Cmp cmp)
{
    erase_range(c, std::equal_range(c.begin(), c.end(), t, cmp));
}

　　查找可通过binary_search, lower_bound, upper_bound, 或者equal_range实现。如果要实现类似map的关键字搜索，有一个技巧，就是用比较函数进行重载，比如学生要按学号查找，则用以下定义：

struct Student
{
    int            id;
    std::string name;

    struct LessThan
    {
        bool operator() (Student const& x, Student const& y)
        {
            return x.id < y.id;
        }

        bool operator() (Student const& x, int id)
        {
            return x.id < id;
        }

        bool operator() (int id, Student const& y)
        {
            return id < y.id;
        }
    };
};

查找学号为5的学生：

std::vector students;

bool exist = std::binary_search(students.begin(), students.end(), 5, Student::LessThan());

删除学号为5的学生：

ordered_erase(students, 5, Student::LessThan());

eXile 2008-01-29 13:13 发表评论

悬挂指针与boost::weak_ptr

eXile — Thu, 11 Oct 2007 03:49:00 GMT

　　与内存泄露相比，C++最令人头痛的问题是内存越界，而内存越界很多情况下是由于悬挂指针引起的。　　
　　假设一个指针变量：
　　Object * ptr;
　　使用ptr时，我们除了要判断ptr是否为0以外，还要怀疑它指向的对象是否有效，是不是已经在别的地方被销毁了。我们希望当它指向的对象被销毁时，ptr被自动置为0。
　　显然，C++没有这种机制，但是，可以借助于boost::weak_ptr做到这一点。

inline void null_deleter(void const *)
{
}

class X
{
private:

    shared_ptr<X> this_;
    int i_;

public:

    explicit X(int i): this_(this, &null_deleter), i_(i)
    {
    }

    X(X const & rhs): this_(this, &null_deleter), i_(rhs.i_)
    {
    }

    X & operator=(X const & rhs)
    {
        i_ = rhs.i_;
    }

    weak_ptr<X> weak_this() const { return this_; }
};

定义变量：
weak_ptr ptr = x.weak_this(); // x为一个X 对象

则当 x 被销毁时，ptr 被自动置为无效。使用方法如下：

if ( shard_ptr safePtr = ptr.lock() ) safePtr->do_something();

这种办法用于单线程中，因为 x 对象可能是基于栈分配的。如果需要在多线程中访问X对象，那么最好的办法还是使用shared_ptr 来管理对象的生命期。这样的话，对于safePtr, 可以保证在 safePtr 的生命期内，它所指向的对象不会被其它线程删除。

eXile 2007-10-11 11:49 发表评论