boost::scoped_array源码学习

scoped_array和scoped_ptr类似，只不过scoped_array是管理数组

#include <iostream>
#include <assert.h>

using namespace std;

template<class T>
class scoped_array
{
private:
	T *px;
	scoped_array(scoped_array const &);  //拷贝构造函数私有化
	scoped_array &operator=(scoped_array const &); //赋值操作私有化
	void operator==(scoped_array const &) const;   //相等判断私有化
	void operator!=(scoped_array const &) const;   //不等判断私有化
public:
	explicit scoped_array(T *p = NULL); //构造函数
	~scoped_array();
	void reset(T *p = NULL);
	T &operator[](ptrdiff_t i) const;
	T *get() const;
	void swap(scoped_array &b);
};

template<class T>
scoped_array<T>::scoped_array(T *p) : px(p)
{
}

template<class T>
scoped_array<T>::~scoped_array()
{
	if (px != NULL)
		delete[] px;
}

template<class T>
void scoped_array<T>::reset(T *p)
{
	assert(p == NULL || p != px);
	scoped_array(p).swap(*this);  //可以保证之前的指针指向内存被释放
}

template<class T>
T &scoped_array<T>::operator[](ptrdiff_t i) const //不明白为什么用ptrdiff_t
{
	assert(px != NULL && i >= 0);
	return px[i];
}

template<class T>
T *scoped_array<T>::get() const 
{
	return px;
}



//--------------------------test-----------------------

class A
{
private:
	int	index;
public:
	A(const int i = 0) : index(i)
	{
		cout << "create object" << endl;
	}
	
	~A()
	{
		cout << "delete object" << index << endl;
	}
	
	void setindex(const int i)
	{
		index = i;
	}
};

int main(int argc, char **argv)
{
	scoped_array<A> p(new A[5]);
	p[0].setindex(1);
	p[1].setindex(2);
	p[2].setindex(3);
	p[3].setindex(4);
	p[4].setindex(5);

	return 0;
}

测试结果：

create object
create object
create object
create object
create object
delete object5
delete object4
delete object3
delete object2
delete object1

从结果可以看出，delete[]调用析构函数的顺序是从后往前