C++博客-colorful-随笔分类-boosthttp://www.cppblog.com/colorful/category/19318.htmlzc qq:1337220912zh-cnFri, 16 Oct 2015 03:01:59 GMTFri, 16 Oct 2015 03:01:59 GMT60STL的remove函数和list的remove成员函数http://www.cppblog.com/colorful/archive/2015/10/14/212010.html多彩人生多彩人生Wed, 14 Oct 2015 07:50:00 GMThttp://www.cppblog.com/colorful/archive/2015/10/14/212010.htmlhttp://www.cppblog.com/colorful/comments/212010.htmlhttp://www.cppblog.com/colorful/archive/2015/10/14/212010.html#Feedback1http://www.cppblog.com/colorful/comments/commentRss/212010.htmlhttp://www.cppblog.com/colorful/services/trackbacks/212010.htmlhttp://www.cnblogs.com/kinuxroot/archive/2013/01/25/stl_remove_problem.html

今天看书刚刚看的，就记录下来吧。这可能是老生常谈了，权且作为一个警醒的例子吧。

大家都知道STL有两个非常重要的组成部分，容器和算法。

算法就是一个个的函数，通过迭代器和容器关联在一起，完成一些工作。

算法和容器的分离为程序设计提供了很大的灵活性，但是也带来了一些负面效果，下面我讲的这个问题就是一个例子。

STL的算法里有一个remove函数，而list自身也有一个remove函数，功能都是一样的，移除某一个元素，那我们应该使用哪一个呢？

看一下下面这段程序

复制代码
 1     list<int> numbers;  2   3     for ( int number = 0; number <= 6; number ++ ) {  4         numbers.push_front(number);  5         numbers.push_back(number);  6     }  7   8     copy(numbers.begin(), numbers.end(),  9             ostream_iterator<int>(cout, " ")); 10     cout << endl; 11  12     // remove algorithm will remove element but not erase the element from container 13     // it will return the logical desination of container 14     list<int>::iterator endOfNumbers = remove(numbers.begin(), numbers.end(), 3); 15  16     copy(numbers.begin(), numbers.end(), 17             ostream_iterator<int>(cout, " ")); 18     cout << endl;
复制代码

输出是什么呢？

第一行肯定是6 5 4 3 2 1 0 0 1 2 3 4 5 6，那么第二行会输出什么？

如果是没有仔细看过STL的人肯定会认为remove(number.begin(), numbers.end(), 3)会移除所有值为3的元素。所以输出是：6 5 4 2 1 0 0 1 2 4 5 6。

但是，我们看一下它真正的输出：

6 5 4 2 1 0 0 1 2 4 5 6 5 6

你可能会非常惊讶，为什么最后会多出5和6两个数呢？

我们来讲一下remove算法的原理。

remove算法工作时并不是直接把元素删除，而是用后面的元素替代前面的元素，也即是说如果我对1234这个序列remove 2，返回的序列是 1344（3被复制到2的位置，4被复制到3的位置）。

这样上面的例子就好解释了，那两个3的元素并没有被移除，而是用后面的元素覆盖了前面的元素。多出的那两个数没有被移除掉而已。

那么我们应该如何真正完成移除呢？remove函数会返回一个迭代器，那个迭代器是这个序列的逻辑终点，也即是我代码里的endOfNumbers，它指向倒数第二个5上。

于是我们要利用list的erase函数完成元素移除

numbers.erase(endOfNumbers, numbers.end());

这样我们就完成了我们的工作，稍稍有点曲折……

其实我们可以把这两步放在一起，比如如果我想接着移除所有值为2的元素

numbers.erase(remove(numbers.begin(), numbers.end(), 2), numbers.end());

这样我们就可以一步到位了。

但是这样好么？

不好。

大家会发现，remove函数的原理是复制而不是指针的移动（因为函数操纵的是迭代器，而C++的迭代器没有定义删除操作），这样会带来一个问题：我们使用list是因为它的修改的效率非常高，改变一下指针就可以了。而这里我们复制了元素，如果在vector中，可能还是高效的，因为vector无论如何都要复制，而对于list就不是如此了，会极度降低我们的效率。

那我们怎么办呢？

答案是使用list自己的remove函数

numbers.remove(1);

我们可以这样删除所有值为1的元素。

也即是说，如果要删除list中的元素，我们应该使用list的remove成员函数，而不是remove算法！

小结

我们都知道，STL是一个效率、复用性、灵活性折衷的产物，其中效率至关重要，所以STL已经禁止了一些效率低的操作（比如list的随机访问），而鼓励你去使用其它的容器。

但是，在算法中，为了灵活性，STL还是会牺牲一些东西，比如我们这个例子。

个人觉得，STL作为C++标准库的一个组成部分，特点和C++本身一模一样，强大而复杂，有些地方难以理解，很多细节需要学习注意，我们要学会避免陷入某些陷阱之中，比如这个例子就是一个效率陷阱。

其它更多的陷阱是错误处理方面的，STL本身并没有规定过多的错误处理，大部分的错误处理都交给了我们，理由很简单：性能至上，如果一个东西自身没有错误检查，我们可以包装一个带错误检查的类；但是如果这个东西自身就带了错误检查，那么我们就没有任何方法提升它的效率了。这也是很多C和C++库的设计原则。

所以，很多时候，需要我们深入细节，然后再决定到底怎么做。因为C++就是如此：有很多路可以走，需要我们自己选择最好的一条路。

分类: C++


多彩人生 2015-10-14 15:50 发表评论
]]>shared_from_this 几个值得注意的地方http://www.cppblog.com/colorful/archive/2012/06/22/179817.html多彩人生多彩人生Fri, 22 Jun 2012 14:42:00 GMThttp://www.cppblog.com/colorful/archive/2012/06/22/179817.htmlhttp://www.cppblog.com/colorful/comments/179817.htmlhttp://www.cppblog.com/colorful/archive/2012/06/22/179817.html#Feedback0http://www.cppblog.com/colorful/comments/commentRss/179817.htmlhttp://www.cppblog.com/colorful/services/trackbacks/179817.htmlshared_from_this()是 enable_shared_from_this<T>的成员 函数，返回shared_ptr<T>。首先需要注意的是，这个函数仅在shared_ptr<T>的构造函数被调用之后才能使 用。原因是enable_shared_from_this::weak_ptr并不在构造函数中设置，而是在shared_ptr<T>的 构造函数中设置。

如下代码是错误的：
  1. class D:public boost::enable_shared_from_this<D>
  2. {
  3. public:
  4.     D()
  5.     {
  6.         boost::shared_ptr<D> p=shared_from_this();
  7.     }
  8. };
复制代码
原 因很简单，在D的构造函数中虽然可以保证enable_shared_from_this<D>的构造函数已经被调用，但正如前面所 说，weak_ptr还没有设置。

如下代码也是错误的：
  1. class D:public boost::enable_shared_from_this<D>
  2. {
  3. public:
  4.     void func()
  5.     {
  6.         boost::shared_ptr<D> p=shared_from_this();
  7.     }
  8. };
  9. void main()
  10. {
  11.     D d;
  12.     d.func();
  13. }
复制代码
错 误原因同上。

如下代码是正确的：
  1. void main()
  2. {
  3.     boost::shared_ptr<D> d(new D);
  4.     d->func();
  5. }
复制代码
这 里boost::shared_ptr<D> d(new D)实际上执行了3个动作：首先调用enable_shared_from_this<D>的构造函数；其次调用D的构造函数；最后调用 shared_ptr<D>的构造函数。是第3个动作设置了enable_shared_from_this<D>的 weak_ptr，而不是第1个动作。这个地方是很违背c++常理和逻辑的，必须小心。

结论是，不要在构造函数中使用shared_from_this；其次，如果要使用shared_ptr，则应该 在所有地方均使用，不能使用D d这种方式，也决不要传递裸指针。   

另一个值得注意的地方是在类的继承树中不能有2个或更多个enable_shared_from_this<T>。例如如下代码是错误的：
  1. class A:public boost::enable_shared_from_this<A>
  2. {
  3. public:
  4.     A():a(1){}
  5.     virtual ~A(){}
  6.     boost::shared_ptr<A> get_ptra(){return shared_from_this();}
  7.     int a;
  8. };
  9. class B:public A,public boost::enable_shared_from_this<B>
  10. {
  11. public:
  12.     B():b(2){}
  13.     boost::shared_ptr<B> get_ptrb()
  14.     {
  15.         return boost::enable_shared_from_this<B>::shared_from_this();
  16.     }
  17.     int b;
  18. };
  19. int _tmain(int argc, _TCHAR* argv[])
  20. {
  21.     {
  22.         boost::shared_ptr<B> x(new B);
  23.         boost::shared_ptr<A> a1 = x->get_ptra();
  24.         boost::shared_ptr<B> b1 = x->get_ptrb();
  25.     }
  26.     return 0;
  27. }
复制代码
注 意上面代码中，B同时拥有2个enable_shared_from_this的基类，一个是 enable_shared_from_this<A>，另一个是enable_shared_from_this<B>。在 boost::shared_ptr<B> x(new B);这行代码中，shared_ptr<B>的构造函数仅会设置2个基类中的一个的weak_ptr。在上面的例子中，仅设置 enable_shared_from_this<A>的。如果修改B的定义为：

class B:public boost::enable_shared_from_this<B>,public A，

则仅设置enable_shared_from_this<B>的weak_ptr。很明显都是错误的。

那么enable_shared_from_this以及shared_ptr为何要如此实现呢？又为什么会有如此怪异的结果呢？

首先考察shared_ptr的构造函数：
  1. template<class Y>
  2. explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
  3. {
  4.     boost::detail::sp_enable_shared_from_this( pn, p, p );
  5. }
  6. template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, boost::enable_shared_from_this<T> const * pe, Y const * px )
  7. {
  8.     if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
  9. }
复制代码
注 意这个sp_enable_shared_from_this是一个模板函数，而且仅调用了一次，所以不可能2个 enable_shared_from_this基类的weak_ptr都被赋值。但问题在于，在调换了B的定义之后结果居然是不一样的。这里有一个很隐 秘的编译器BUG。按道理来说，编译器在编译这段代码时，应该注意到无法真正决断该怎么实例化sp_enable_shared_from_this并且 报一个错，但vc 2008并没有报错，而是通过编译了。（g++会在此处报错）

那么正确的解法是怎样的呢？
  1. class B:public A
  2. {
  3. public:
  4.     B():b(2){}
  5.     boost::shared_ptr<B> get_ptrb()
  6.     {
  7.         return boost::dynamic_pointer_cast<B>(shared_from_this());
  8.     }
  9.     int b;
  10. };
复制代码
注 意到这里B并没有直接继承enable_shared_from_this，而是使用dynamic_pointer_cast进行了类型转换。

关于为什么enable_shared_from_this是这样实现的，可以参看作者原文：

Every enable_shared_from_this base contains a weak_ptr, The shared_ptr constructor looks up the enable_shared_from_this base and initializes its weak_ptr accordingly. This doesn't work when there are
two or more enable_shared_from_this bases, though.

I could put the weak_ptr in a virtual polymorphic base. This would force polymorphism on all clients of enable_shared_from_this... probably acceptable. It will also force a dynamic_pointer_cast in every
shared_from_this, and this may be harder to swallow, particularly in cases where RTTI is off. So I'm not sure.

If you do want the above behavior, it's easy to duplicate, as I already responded in my first post on the topic. Just make FooB return dynamic_pointer_cast<B>( FooA() ) and remove the enable_shared_from_this<B>
base (A needs to be made polymorphic, of course).

注意为了让dynamic_pointer_cast能工作，A必须具有虚函数，那么最简单的做法当然是令其析构函 数为虚函数（通常一个class如果希望被继承，析构函数就应该为虚函数）。

多彩人生 2012-06-22 22:42 发表评论
]]>enable_shared_from_this（转载）http://www.cppblog.com/colorful/archive/2012/06/22/179816.html多彩人生多彩人生Fri, 22 Jun 2012 14:41:00 GMThttp://www.cppblog.com/colorful/archive/2012/06/22/179816.htmlhttp://www.cppblog.com/colorful/comments/179816.htmlhttp://www.cppblog.com/colorful/archive/2012/06/22/179816.html#Feedback0http://www.cppblog.com/colorful/comments/commentRss/179816.htmlhttp://www.cppblog.com/colorful/services/trackbacks/179816.html

在 C++ 中需要自己来处理内存，稍微处理不当，就会存在非常郁闷的内存泄漏问题

 

还好，现在 C++ 中推出了强大的智能指针，即 smart_ptr ，本文先稍微介绍一下 smart_ptr ，然后具体说说 shared_ptr 和 weak_ptr ，特别是 enable_shared_from_this 和 shared_from_this

 

除了标准库中的 auto_ptr 之外

在 boost 或者 tr1 中的 smart_ptr 主要是有下面几种

  • scoped_ptr
  • scoped_array
  • shared_ptr
  • shared_array
  • intrusive_ptr
  • weak_ptr

这些里面最难理解的是综合应用了 weak_ptr 和 shared_ptr 的 enable_shared_from_this 类，在该类中定了成员函数 shared_from_this() ，返回 shared_ptr<T> 。这个函数仅在 shared_ptr<T> 的构造函数被调用之后才能使用。原因是 enable_shared_from_this::weak_ptr 并不在构造函数中设置（此处的构造函数指的是类型 T 的构造函数），而是在 shared_ptr<T> 的构造函数中设置（此处的构造函数指的是类型 shared_ptr<T> 的构造函数）。

 

在下面的代码中：

 

Cpp代码
  1. #include <iostream>   
  2.   
  3. #include <string>   
  4.   
  5.     
  6.   
  7. #include <boost/shared_ptr.hpp>   
  8.   
  9. #include <boost/weak_ptr.hpp>   
  10.   
  11. #include <boost/enable_shared_from_this.hpp>   
  12.   
  13.     
  14.   
  15. using namespace std;   
  16.   
  17.     
  18.   
  19. struct Ansible   
  20.   
  21.   : public boost::enable_shared_from_this<Ansible>   
  22.   
  23. {   
  24.   
  25.     boost::shared_ptr<Ansible> get_shared()   
  26.   
  27.     {   
  28.   
  29.         boost::shared_ptr<Ansible> r(this);   
  30.   
  31.     
  32.   
  33.         return r;   
  34.   
  35.     }   
  36.   
  37.     
  38.   
  39.     ~Ansible()   
  40.   
  41.     {   
  42.   
  43.         cout<<"Destructor"<<endl;   
  44.   
  45.     }   
  46.   
  47. };   
  48.   
  49.     
  50.   
  51. int main(int argc,char* argv[])   
  52.   
  53. {   
  54.   
  55.     boost::shared_ptr<Ansible> a(new Ansible);   
  56.   
  57.     Ansible& r = *a;   
  58.   
  59.     //boost::shared_ptr<Ansible> b = r.get_shared();   
  60.   
  61.     boost::shared_ptr<Ansible> b = r.shared_from_this();   
  62.   
  63.     
  64.   
  65.     cout<<"Reference Number "<<a.use_count()<<" "<<b.use_count()<<endl;   
  66.   
  67.     
  68.   
  69.     return 0;   
  70.   
  71. }   
#include <iostream> #include <string> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> #include <boost/enable_shared_from_this.hpp> using namespace std; struct Ansible : public boost::enable_shared_from_this<Ansible> { boost::shared_ptr<Ansible> get_shared() { boost::shared_ptr<Ansible> r(this); return r; } ~Ansible() { cout<<"Destructor"<<endl; } }; int main(int argc,char* argv[]) { boost::shared_ptr<Ansible> a(new Ansible); Ansible& r = *a; //boost::shared_ptr<Ansible> b = r.get_shared(); boost::shared_ptr<Ansible> b = r.shared_from_this(); cout<<"Reference Number "<<a.use_count()<<" "<<b.use_count()<<endl; return 0; }

 

若不使用 shared_from_this() 成员函数，则会输出 a 和 b 的 use_count() 都为 1 ，然后调用 2 次类型 Ansible 的析构函数，若添加了该成员函数，在 a 和 b 的 use_count() 输出为 2 ，只是调用一次 Ansible 的析构函数。原因是 enable_shared_from_this 里面在 shared_ptr<T> 的时候构造了一个 weak_ptr 类，而 weak_ptr 只是监视，不增加引用计数

 

（下面是转载： http://huyuguang1976.spaces.live.com/blog/cns!2A9E272E3C33AFF1!185.entry ）

所以如下代码是错误的：

 

class D:public boost::enable_shared_from_this<D>

{

public:

    D()

    {

        boost::shared_ptr<D> p=shared_from_this();

    }

};

 

原因很简单，在 D 的构造函数中虽然可以保证 enable_shared_from_this<D> 的构造函数已经被调用，但正如前面所说， weak_ptr 还没有设置。

 

如下代码也是错误的：

 

class D:public boost::enable_shared_from_this<D>

{

public:

    void func()

    {

        boost::shared_ptr<D> p=shared_from_this();

    }

};

 

void main()

{

    D d;

    d.func();

}

 

错误原因同上。

 

如下代码是正确的：

 

void main()

{

    boost::shared_ptr<D> d(new D);

    d->func();

}

 

这里 boost::shared_ptr<D> d(new D) 实际上执行了 3 个动作：首先调用 enable_shared_from_this<D> 的构造函数；其次调用 D 的构造函数；最后调用 shared_ptr<D> 的构造函数。是第 3 个动作设置了 enable_shared_from_this<D> 的 weak_ptr ，而不是第 1 个动作。这个地方是很违背 c++ 常理和逻辑的，必须小心。

 

结论是，不要在构造函数中使用 shared_from_this ；其次，如果要使用 shared_ptr ，则应该在所有地方均使用，不能使用 D d 这种方式，也决不要传递裸指针。


另解：：：：：
struct X

{

         boost::shared_ptr<X> getX()

{

         boost::shared_ptr<X> r ;//????如何实现

         return r;

}

};

 

要得到X的智能指针,只是在对象指针是受shared_ptr保护的基础上的,举例如下:

void test_X()

{

         {

X x;

                  boost::shared_ptr<X> px = x.getX();//错误

}

         {

X* x = new X();

boost::shared_ptr<X> px = x->getX();//错误

}

         {

boost::shared_ptr<X>  x (new X());

boost::shared_ptr<X> px = x->getX();//正确

}

}



多彩人生 2012-06-22 22:41 发表评论
]]>关于boost::thread 的一件怪事http://www.cppblog.com/colorful/archive/2012/05/14/174897.html多彩人生多彩人生Mon, 14 May 2012 13:50:00 GMThttp://www.cppblog.com/colorful/archive/2012/05/14/174897.htmlhttp://www.cppblog.com/colorful/comments/174897.htmlhttp://www.cppblog.com/colorful/archive/2012/05/14/174897.html#Feedback0http://www.cppblog.com/colorful/comments/commentRss/174897.htmlhttp://www.cppblog.com/colorful/services/trackbacks/174897.html
#include <cstdio>
#include <boost/thread.hpp>
#include <boost/bind.hpp>

int fun1()
{
   for(int i=0; i<10; i++)
      printf("哈哈哈哈哈哈\n");
   return 0;
}

int fun2(int count)
{
   for(int i=0; i<count; i++)
      printf("呵呵呵呵呵呵\n");
   return 0;
}

int main()
{
   boost::thread(fun1);     // 不以打印
   boost::thread(fun2, 10); // 可以打印
   boost::thread t(fun1);   // 可以打印

   getchar();
   return 0;
}
不知什么原因，知道的可以告诉我吗

多彩人生 2012-05-14 21:50 发表评论
]]>