一、什么时候需要重载赋值操作符,编译器是否提供默认的赋值操作符
1.编译器为每个类默认重载了赋值操作符
2.默认的赋值操作符仅完成浅拷贝的工作
3.当需要完成深拷贝时必须重载赋值操作符
4.赋值操作符与拷贝构造函数存在相同的意义
#include<iostream>
using namespace std;
class Test
{
private:
int *m_poiter;
public:
Test()
{
m_poiter = NULL;
}
Test(int i)
{
m_poiter = new int(i);
}
void print()
{
cout << hex << m_poiter << endl;
}
~Test()
{
delete m_poiter;
}
};
int main()
{
Test t1(10);
Test t2 = t1;
t1.print();
t2.print();
return 0;
}
结果会先打印两个相同的地址,然后程序崩溃 原因:调用两次析构函数对同一片内存释放了两次
拷贝构造函数和重载赋值操作符
#include<iostream>
using namespace std;
class Test
{
private:
int *m_poiter;
public:
Test()
{
m_poiter = NULL;
}
Test(int i)
{
m_poiter = new int(i);
}
Test(const Test& obj)
{
m_poiter = new int(*obj.m_poiter);
}
Test& operator =(const Test& obj)
{
if(this != &obj)
{
delete m_poiter;//在生成对象的时候在堆空间里边分配了内存,故要先删掉再指向新的内存
m_poiter = new int(*obj.m_poiter);
}
return *this;
}
void print()
{
cout << hex << m_poiter << endl;
}
~Test()
{
delete m_poiter;
}
};
int main()
{
Test t1(10);
Test t2 = t1;
t1.print();
t2.print();
return 0;
}
赋值操作符重载时要注意:
*1.返回值是引用
2.参数是引用
3.判断是否为自赋值(用地址来比较)
4.返回当前对象*
二、数组类:二阶构造模式将拷贝构造函数定义为private,外部不能调用,不能进行拷贝构造了
Array& Array::operator = (const Array& obj)//1.返回值是引用 2.参数是引用
{
if(this != &obj)//3.判断是否是自赋值
{
int *poiter = new int[obj.m_length];
if(poiter != NULL)
{
for(int i = 0; i < obj.m_length; i++)
{
poiter[i] = obj.m_poiter[i];
}
delete[] m_poiter;
m_length = obj.m_length;
m_poiter = poiter;
}
}
return *this;//4.返回的是当前对象
}
完整程序:
array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_
#include<iostream>
class Array
{
private:
int m_length;
int *m_poiter;
Array(int length);
Array(const Array& obj);
bool construct();
public:
int get_length();
static Array* NewInsrance(int length);
int& operator [] (int index);
Array& self();
Array& operator = (const Array& obj);
~Array();
};
#endif
array.cpp:
#include"array.h"
Array::Array(int length)
{
m_length = length;
}
bool Array::construct()
{
bool ret = true;
m_poiter = new int[m_length];
if(m_poiter)
{
for(int i = 0; i < m_length; i++)
{
m_poiter[i] = 0;
}
}
else
{
ret = false;
}
return ret;
}
Array* Array::NewInsrance(int length)
{
Array* ret = new Array(length);
if(!(ret && ret->construct()))
{
delete ret;
ret = NULL;
}
return ret;
}
int Array::get_length()
{
return m_length;
}
int& Array::operator [] (int index)
{
return m_poiter[index];
}
Array& Array::self()
{
return *this;
}
Array& Array::operator = (const Array& obj)
{
if(this != &obj)
{
int *poiter = new int[obj.m_length];
if(poiter != NULL)
{
for(int i = 0; i < obj.m_length; i++)
{
poiter[i] = obj.m_poiter[i];
}
delete[] m_poiter;
m_length = obj.m_length;
m_poiter = poiter;
}
}
return *this;
}
Array::~Array()
{
delete[] m_poiter;
}
main.cpp:
#include"array.h"
using namespace std;
int main()
{
Array* array = Array::NewInsrance(5);
Array* brray = Array::NewInsrance(10);
if(array && brray)
{
Array& a = array->self();
Array& b = brray->self();
cout << a.get_length()<<endl;
cout << b.get_length()<<endl;
a = b;
cout << a.get_length()<<endl;
cout << b.get_length()<<endl;
}
delete array;
delete brray;
return 0;
}
打印结果;
lgc@ubuntu:/home/c++$ ./a.out
5
10
10
10
三、编译器默认提供的函数
class Test
{
};
等价于
class Test
{
Test();
Test(const Test& obj);
Test& operator = (const Test& obj);
~Test();
};
所以面试时一定要注意这种问题
四、关于string类的问题
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s = "12345";
const char* p = s.c_str();//c_str()返回一个c方式的指针
cout<< p <<endl;//12345
s.append("abcd");//append()在字符串s后插入abcd
cout<< p <<endl;//12345
cout<< s <<endl;//12345abcd
return 0;
}
输出这些结果的原因,这里既有c编程又有c++编程:
1.append函数之前,string对象内部执行数据的char* 指针
和指针p指向同一片内存空间
2.append执行时,“12345”和“abcd”被复制到另一片内存空间,同时释放原来的空间,从而p成为野指针
#include<iostream>
#include<string>
using namespace std;
int main()
{
const char* p = "12345";
string s = "";
s.reserve(10);
for(int i = 0; i < 5; i++)
{
s[i] = p[i];
}
cout<< s <<endl;//输出空字符串
for(int i = 0; i < 5; i++)
{
cout<<s[i]<<endl;//输出12345
}
return 0;
}
原因解析:
数据指针指向的内存空间的内容改变了,但是代表字符串长度的变量并没有改变,因而string对象依然认为自己是空的字符串
解决方法:c++中少用指针开发,要尽量避免c的编程思想
#include<iostream>
#include<string>
using namespace std;
int main()
{
string p = "12345";
string s = p;
cout<<s<<endl;
return 0;
}
小结:
1.在需要进行深拷贝的时候必须重载赋值操作符
2.赋值操作符与拷贝构造函数用同等重要的意义
3.string类通过一个数据空间保存字符数据
4.string类通过一个成员变量保存当前字符串的长度
5.c++开发时尽量避开C语言中惯用的编程思想