C++沉思录第十三章读书笔记２

template class Array {

public:

Array():data(0), sz(0) {}

Array(unsigned size):

sz(size), data(new T[size]) {}

~Array() { delete [] data; }

const T& operator[ ](unsigned n) const

{

if(n >= sz || data ==0)

throw "Array subscript out of range";

return data[n];

}

T& operator[] (unsigned n)

{

if(n >= sz || data == 0)

throw "Array subscript out of range ";

return data[n];

}

operator const T*() const

{

return data;

}

operator T*()

{

return data;

}

private:

T* data;

unsigned sz;

Array(const Array& a);

Array& operator=(const Array&);

};

template class Pointer {

public:

Pointer(Array& a, unsigned n = 0):

ap(&a), sub(n) {};

Pointer(): ap(0), sub(0) {};

T& operator* () const { //加&和不//加的区别，还是

//要自己调程序

if(ap == 0)

throw "*of unbound Pointer";

return (*ap) [sub];

}

private:

Array* ap;

unsigned sub;

};

int main()

{

/*

Array* ap = new Array (10);

Pointer p(*ap, 5);

Delete ap;

*p=t2;

*/

Array x(20);

int a[5];

Pointer p(x,20);

*p =5; //终于明白为什么要返回要加&，加的话就可以修改，不然只是返

///回一个临时值。

//*(p+1) =1; 有错误！

int t = *p;

cout << t<

}

13-3遗留问题

到目前为止，只设法增加了一个防止出错的中间层。现在如果Array不存在了，还可能存在一个指向它的某个元素的空悬Pointer.

通过引进一个额外的中间层，我们能够解决任何问题。如果想要删除了Array对象后仍然保留数据，就可以运用这个定理，既让Array指向数据而不是包含数据。

现在每个Pointer对象都指向一个Array_data对象，而不是一个Array对象。每个Array_data对象都会包含一个引用计数。

因为这个类不是直接提供用户使用的，所以成员都是私有的。

template class Array_data {

friend class Array< T >;

friend class Pointer;

Array_data(unsigned size = 0):

data(new T[size]), sz(size), use(1) {}

~Array_data() { delete [] data; }

const T& operator[] (unsigned n) const

{

if(n>=sz)

throw "Array subscript out of range";

return data[n];

}

T& operatir[](unsigned n)

{

if(n>= sz)

throw "Array subscript out of range";

return data[n];

}

//没有实现，不允许复制操作。

Array_data(const Array_data&);

Array_data& operator=(const Array_data&);

T*data;

unsigned sz;

int use;

};

template class Array {

friend class Pointer;

public:

Array(unsigned size):

data(new Array_data(size)) {}

~Array() {

if(--data->use == 0)

delete data;

}

const T& operator[] (unsigned n) const {

return (*data)[n];

}

T& operator[](unsigned n) {

return (*data)[n];

}

private:

Array(const Array&);

Array& operator =(const Array&);

Array_data* data;

};

template clss Pointer:public Ptr_to_const {

public:

Pointer(Array& a, unsigned n = 0):

Ptr_to_const (a,n) {}

Pointer():ap(0), sub(0) {}

Pointer(const Pointer& p):ap(p.ap), sub(p.sub) {

if(ap)

++ap->use;

}

Pointer& operator=(const Pointer& p) {

if(p.ap)

++p.ap->use;

if(ap && --ap->use == 0)

delete ap;

ap = p.ap;

sub = p.sub;

return *this;

}

T& operator*() const {

if(ap == 0)

throw "*of unbound Ptr_to_const";

return (*ap)[sub];

}

private:

Array_data* ap;

unsigned sub;

};

这部分没有调试出来，不知道错误在哪里？

为什么操作符［］不能用呢？