运算符重载,浅拷贝(logical copy) ,vs, 深拷贝(physical copy)，三大件（bigthree problem）

一般的我们喜欢这样对对象赋值：

Person p1;Person p2=p1;

classT object(another_object), or    A a(b);

classT object = another object;

class A

{

//  …

};

int main( )

{

A x;

A y(x);

// …

A z = x;

z = y;

}

这样的话，如果成员变量中有指针的话，就容易造成指针的二次删除。这样就需要我们显示的在类中实现

1、拷贝构造，

2、赋值运算符重载。

1）、判断是不是自赋值，2）、释放旧空间，3）、开辟新空间。4）、内容本身的        拷贝，5）、返回*this

3、析构函数（释放指针指向的空间）。

这三步使类实现深拷贝，从而避免浅拷贝的二次删除问题。俗称三大件。

class Vector

{

private:

int *rep;

int size;

void clone(const Vector& a);

void dispose( );

public:

Vector(int s=0);

// a default constructor initializing all members of rep to 0 if s is not 0.

Vector( int*, int );

// a constructor creates a Vector object from an ordinary array

Vector(const Vector& v); // a copy constructor

~Vector( ) {dispose( );} // a destructor

int get_size( ) const {return size;} // an accessor

const Vector& operator=(const Vector& x);

int& operator[ ](int index) {return rep[index];}

const int& operator[ ](int index) const {return rep[index];}

};

//Vector v;

//V = a;

//Vector v(a);

void Vector::clone(const Vector& a)

{

this->size = a.size;      rep = new int[size];

for (int count = 0; count < size; ++count)

rep[count] = a[count]; // (*this)[count] = a[count];

// rep[count] = a.rep[count];

}

void Vector::dispose( )

{

delete [ ] rep;

rep = NULL;

}

Vector::Vector(int s) : size(s)

{

if (size <= 0)

{ rep = NULL; }

else

{

rep = new int[size];

for (int count = 0; count < size; ++count)

{ rep[count] = 0; }     }

}

Vector::Vector(int* a, int s) : size(s), rep(new int[s])

{

for (int count = 0; count < size; ++count)

{ rep[count] = a[count]; }

}

Vector::Vector(const Vector& v)

{ clone(v); }

//for example: Vector a, v; a.=(v);

const Vector& Vector::operator=(const Vector& x)

{

if ( this != &x )  //Vector v; Vector* p = &v; v = *p;

{

delete []rep;

this->size = x.size;

rep = new int[size];

for (int count = 0; count < size; ++count)

rep[count] = x[count];

}

return *this;

}

// overloading operator <<, not a friend function

ostream& operator<<(ostream& out, const Vector& x)

{

int s = x.get_size( );

for (int i = 0; i < s; ++i)

{

out << x[i]<<endl; // out<<x.rep[i]<<endl;

}

out << endl;

return out;

}

bool operator==(const Vector& a, const Vector& b)

{

bool yes = true;

if (a.get_size( ) != b.get_size( ))

{ yes = false; }

else

{

int s, index = 0;

s = a.get_size( );

while (index < s && a[index] == b[index])

{ ++index; }

if (index < s)

{ yes = false; }

}

return yes;

}

int main()

{

Vecter vec1;

cout<<vec1<<endl;

int array[5] = {1,2,3,4,5};

Vector vec2( array, 5 );

cout<<vec2<<endl;

Vector vec3( vec2 );

cout<<vec3<<end;

if( vec3 == vec2 )

{

Cout<<”The vector3 is equal to vector2”<<endl;

}

Vector vec4;

vec4 = vec3;

cout<<vec4<<end;

return 0;

}