请教一个STL的问题

hh942111

刚刚在测试list,auto_ptr的相关使用方法，但是代码编译通不过！请大家帮忙解决。
代码如下

1. #include <list>;
   
2. #include <vector>;
   
3. #include <memory>;
   
4. #include <iostream>;
   
5. 
   
6. using namespace std;
   
7. 
   
8. class test
   
9. {
   
10. public:
    
11.         test( int k = 0 )
    
12.         {
    
13.                 i = k;
    
14.                 cout << "test BBBB - " << i << endl;
    
15.         }
    
16.         ~test()
    
17.         {
    
18.                 cout << "test DDDD - " << i << endl;
    
19.         }
    
20.         test( const test& t )
    
21.         {
    
22.                 this->;i = t.i;
    
23.         }
    
24.         const test& operator=( const test& t )
    
25.         {
    
26.                 this->;i = t.i;
    
27.                 return *this;
    
28.         }
    
29. 
    
30. private:
    
31.         int i;
    
32. };
    
33. 
    
34. typedef auto_ptr<test>; test_ptr;
    
35. typedef list<test_ptr>; test_list;
    
36. 
    
37. int main()
    
38. {
    
39.         test_list tl;
    
40. 
    
41.         for( int i = 0; i < 10; i++ )
    
42.         {
    
43.                 test_ptr ptr( new test( i ) );
    
44.                 tl.push_back( ptr );
    
45.         }
    
46. }

复制代码

编译提示

/usr/include/g++-3/stl_construct.h: In function `void construct (_T1 *,
const _T2 & [with _T1 = test_ptr, _T2 = auto_ptr<test>;]':
/usr/include/g++-3/stl_list.h:293:   instantiated from `list<_Tp, _Alloc>;::_M_create_node (const _Tp & [with _Tp = test_ptr, _Alloc = allocator<test_ptr>;]'
/usr/include/g++-3/stl_list.h:344:   instantiated from `list<_Tp, _Alloc>;::insert (_List_iterator<_Tp, _Tp &, _Tp *>;, const _Tp & [with _Tp = test_ptr, _Alloc = allocator<test_ptr>;]'
/usr/include/g++-3/stl_list.h:381:   instantiated from `list<_Tp, _Alloc>;::push_back (const _Tp & [with _Tp = test_ptr, _Alloc = allocator<test_ptr>;]'
a.cpp:44:   instantiated from here
/usr/include/g++-3/stl_construct.h:48: passing `const auto_ptr<test>;'
as `this' argument of `auto_ptr<_Tp>;:perator
auto_ptr<_Tp>;::auto_ptr_ref<_Tp1>; () [with _Tp1 = test, _Tp = test]'
discards qualifiers

dzho002

这里有一些Smart Pointers的讨论,你可以看看
http://ootips.org/yonat/4dev/

hh942111

上面的拷贝构造函数漏了东西，应该如下

1.     Smart_ptr(const Smart_ptr& rhs)
   
2.     : m_pData(rhs.m_pData)，
   
3.     m_pCount(rhs.m_pCount)
   
4.     {
   
5.             m_pCount->;AtomicIncrement();
   
6.     }
   

复制代码

hh942111

我的本意是对一个很大的类，比如Test，在与STL结合时希望避免拷贝对象的开销。由于auto_ptr不能配合STL使用，所以考虑效率和使用STL容器，我希望实现自己的智能指针提供这样的功能，这里可以提供实现思路（当然真正的实现还需要考虑更多的东西）

1. class Smart_ptr
   
2. {
   
3. private:
   
4.     // 计数器
   
5.     // CAtomicCounter对象管理计数值，其AtomicIncrement递增计数值
   
6.     // AtomicDecrement递减计数值并且在其值为0时返回true
   
7.     // 在CAtomicCounter内部可以实现多线程的保护
   
8.     mutable CAtomicCounter* m_pCount;
   
9.     // 保存的对象指针
   
10.     Test *m_pData;
    
11. 
    
12. public:
    
13.         Smart_ptr( Test *p )
    
14.         : m_pData( p )
    
15.         {
    
16.         m_pCount = new CAtomicCounter( 1 );
    
17.         }
    
18.                
    
19.     Smart_ptr(const Smart_ptr& rhs)
    
20.     : m_pData(rhs.m_pData)
    
21.     {
    
22.             m_pCount->;AtomicIncrement();
    
23.     }
    
24. 
    
25.         ~Smart_ptr()
    
26.         {
    
27.                 if( m_pCount->;AtomicDecrement() )
    
28.         {
    
29.             delete m_pCount;
    
30.                     m_pCount = NULL;
    
31.                     delete m_pData;
    
32.         }
    
33.     }
    
34. }
    

复制代码

whyglinux

带引用计数的智能指针不是C++标准库中的吧。如果你自己实现，我觉得非常困难。增加引用计数非常容易，但是如何减少计数呢？我觉得这是关键，也是难点，你好好考虑考虑。

还有，要正确区分“重载”和“派生”的概念，你在上面有误用。

我说的是以 list 类为基类派生一个新的类，比如叫 pointer_list，专门用来处理元素是指针的情况，在它的析构函数中释放指针指向对象所占用的存储空间。

从你上面的帖子可以看出，你是想用指向 auto_ptr 的指针作为派生类的元素，完全没有这个必要，用普通的指针即可，如 pointer_list< test* >;，而不是 pointer_list< auto_ptr* >; 或者你的 pointer_list< SmartPtr* >;，这时使用它们没有任何的优越性，只能是一种负担。

hh942111

还有用自定义的适配STL的SmartPtr的方案有另一个好处，可以提供＝＝，<运算符的重载以使用map,set等等容器，而用重载list<SmartPtr*>;的方案就不够通用了

hh942111

其实用whyglinux上面提到的重载list<SmartPtr*>;，在析构函数中对每个SmartPtr*调用delete的方法也可以，但是又增加了一个适配层，大家发表一下意见，到底哪种方案好呢？

hh942111

这个方案我也想到了，并且在一个项目中就是这么做的！但是它还是解决不了智能指针（带引用计数）使用标准模板库的问题，我的想法是在自己实现智能指针时，对于引用计数申明时增加mutable限定符，这样在拷贝时就可以对const SmartPtr&对象改变其引用计数，这样资源管理的自动化和标准模板库的强大特性都可以获得！
不知whyglinux对这个解决方案有何看法？

whyglinux

以 list 类为基类派生一个新的类，在新类的析构函数中处理内存空间的回收问题。

hh942111

针对上面我们讨论的这个list与auto_ptr的问题！我想再跟大家继续讨论一下，对上面的例子程序而言，test是一个很小的类，实现的拷贝构造函数也就不存在效率问题，但是如果我的应用中实际是一个很大的类，那么频繁的复制操作就效率太低下了，而且对我得应用来说，生成一个test对象然后把它加入list中，然后有list来管理其生命周期是很合理的用法！同时我不想每次都要付出复制对象的代价！如果用list<test*>;的话又失去了对test对象资源管理的自动化。
大家有什么好的解决方案吗？可以在这里讨论讨论啊！同时希望whyglinux兄台继续发表高见