C++智能指针

今天复习了一下智能指针,然后动了动脑子,恍然觉得以前并没有真正的理解智能指针。首先是shared_ptr,shared_ptr的作用就不做介绍了。那么shared_ptr是如何实现的呢?我分析了一下,智能指针的要点就是“计数”和“指针”。所以智能指针的成员变量中就必须有计数值和对象指针。

指针计数为零的时候自动销毁,所以析构函数中需要实现计数和对象销毁的功能。然后还要注意的就是复制构造函数和复制函数(operator=)。想起来觉得也不难实现,于是就动手写了个丑陋版shared_ptr。

[cpp]

#include <iostream>

namespace toy{
template<class T>
class shared_pointer{

public:
template<class Y> explicit shared_pointer(Y* p) {
px = p;
shared_counter = new long(1);
}
~shared_pointer() {
if(*shared_counter >= 1)
(*shared_counter)–;
else
delete px;
}
template<class Y> shared_pointer(shared_pointer<Y> &r) {
px = r.px;
shared_counter = r.shared_counter;
(*shared_counter)++;
}
template<class Y> shared_pointer & operator=(shared_pointer<Y> const & r) {
if(*shared_counter >= 1)
(*shared_counter)–;
else
delete px;
px = r.px;
shared_counter = r.shared_counter;
(*shared_counter)++;
return *this;
}

T & operator*() const {
return *(this->px);

} // never throws
T * operator->() const {
return this->px;
} // never throws
T * get() const; // never throws
void swap(shared_pointer & b){
T* tmp_ptr;
long* tmp;
tmp_ptr = b.px;
b.px = px;
px = tmp_ptr;
tmp = b.shared_counter;
b.shared_counter = shared_counter;
shared_counter = tmp;
}
public:
T* px;
long* shared_counter;
};
};

int main(int argc, char** argv){

toy::shared_pointer<int> sp1(new int(233));
toy::shared_pointer<int> sp2(new int(123));
std::cout<<*(sp1.shared_counter)<<std::endl;
toy::shared_pointer<int> sp3 = sp1;
std::cout<<*(sp3.shared_counter)<<std::endl;
sp3 = sp2;
std::cout<<*(sp1.shared_counter)<<std::endl;
std::cout<<*(sp2.shared_counter)<<std::endl;
sp3.swap(sp1);
std::cout<<*(sp1.shared_counter)<<std::endl;
std::cout<<*(sp3.shared_counter)<<std::endl;

std::cout<<"*sp1 = "<<*sp1<<std::endl;
std::cout<<"*sp2 = "<<*sp2<<std::endl;

return 0;
}
[/cpp]

看到有的博客讨论shared_ptr安全性的问题。其中引用了boost文档中的一段话说shared_ptr 对象提供与内建类型一样的线程安全级别。一个 shared_ptr 实例可以同时被多个线程“读”(仅使用不变操作进行访问)。 不同的 shared_ptr 实例可以同时被多个线程“写入”(使用类似 operator= 或 reset 这样的可变操作进行访问)(即使这些实 例是拷贝,而且共享下层的引用计数)。

博文中使用了下面这个测试用例。

[cpp]
#include <stdio.h>
#include <tr1/memory>
#include <pthread.h>

using std::tr1::shared_ptr;

shared_ptr<int> gp(new int(2000));

shared_ptr<int> CostaSwapSharedPtr2(shared_ptr<int> & p)
{
shared_ptr<int> p2(new int(1000));
p.swap(p2);
p2.swap(p);
return p;
}

void* thread_start(void * arg)
{
int i =0;
for(;i<100000;i++)
{
shared_ptr<int> p= CostaSwapSharedPtr2(gp);
if(*p!=2000)
{
printf("Thread error. *gp=%d \n", *gp);
break;
}
}
printf("Thread quit \n");
return 0;
}

int main()
{
pthread_t thread;
int thread_num = 10, i=0;
pthread_t* threads = new pthread_t[thread_num];
for(;i<thread_num;i++)
pthread_create(&threads[i], 0 , thread_start , &i);
for(i=0;i<thread_num;i++)
pthread_join(threads[i],0);
delete[] threads;
return 0;
}
[/cpp]

这个测试例子其实是不太对的,在CostaSwapSharedPtr2()函数中连续两次使用了swap()函数。即使swap()函数是原子性的操作,这也会导致测试出错。所以这并不是一个正确的测试方法。
事实上,swap()函数并不是原子性的。其实现中不可能使用xchg指令,因为有两个共享指针,不能同时操作。其次,share_ptr的实现也没有使用互斥量这些东西,所以对同一个share_ptr的写肯定不是线程安全的。其他的智能指针感觉原理都差不多,感觉像是功能阉割版的share_ptr,就先不管了。

发表评论