第三十六课：经典问题解析三----------狄泰软件学院

一、什么时候需要重载赋值操作符，编译器是否提供默认的赋值操作符

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语言中惯用的编程思想