1，关于赋值的疑问：

    1，什么时候需要重载赋值操作符？

    2，编译器是否提供默认的赋值操作符？

   

2，关于赋值的疑问：

    1，编译器为每个类默认重载了赋值操作符；

       1，意味着同类型的类对象可以相互赋值；

    2，默认的赋值操作符仅完成浅拷贝；

    3，当需要进行深拷贝时必须重载赋值操作符；

       1，和拷贝构造函数相同；

    4，赋值操作符与拷贝构造函数有相同的存在意义；

   

3，默认赋值操作符重载编程实验：

    1，main.cpp 文件：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int* m_pointer;
public:
    Test()
    {
        m_pointer = NULL;
    }
    Test(int i)
    {
        m_pointer = new int(i);
    }
    Test(const Test& obj)
    {
        m_pointer = new int(*obj.m_pointer);
    }
    Test& operator = (const Test& obj)  
    {
        if( this != &obj )  // 避免自赋值；
        {
            delete m_pointer;
            m_pointer = new int(*obj.m_pointer);
        }
        
        return *this;
    }
    void print()
    {
        cout << "m_pointer = " << hex << m_pointer << endl;
    }
    ~Test()
    {
        delete m_pointer;
    }
};

int main()
{
    Test t1 = 1;
    Test t2;
    
    t2 = t1;  // 默认赋值操作符的浅拷贝使得两个对象内部指针指向同一片空间；

    int i = 0;  // C 语言中允许这样，所以 C++ 中也必须允许；
    i = i;

    t2 = t2;  // C++  中也要允许自赋值，但是没有意义；
    
    t1.print();
    t2.print();
    
    return 0;
}

　2，输出结果：

　　m_pointer = 0x9387008

　　m_pointer = 0x9387018

　3，赋值操作符重载注意事项：

　　1，赋值操作符返回值一定是引用，为了连续赋值；

　　2，参数类型一定是 const Type&；

       3，不能自赋值；

       4，返回当前对象；

 

4，关于赋值的疑问：

 

    1，如果要进行深拷贝，拷贝构造函数和赋值操作符的实现都要自定义；

   

5，一般性原则：

    1，重载赋值操作符，必然要实现深拷贝；

       1，实现深拷贝和自定义赋值操作符及拷贝构造函数是充要条件；

   

6，数组类的优化编程实验：

    1，IntArray.h 文件：

#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
    int m_length;
    int* m_pointer;
    
    IntArray(int len);
    IntArray(const IntArray& obj);
    bool construct();
public:
    static IntArray* NewInstance(int length); 
    int length();
    bool get(int index, int& value);
    bool set(int index ,int value);
    int& operator [] (int index);
    IntArray& operator = (const IntArray& obj);
    IntArray& self();
    ~IntArray();
};

    2，首先写出赋值操作符注意事项模板：

IntArray& IntArray::operator = (cosnt IntArray& obj)
{
     if( this != &obj )
     {
         
     }

     return *this;
}

    3，函数实现：

IntArray& IntArray::operator = (const IntArray& obj)
{
    if( this != &obj )
    {
        int* pointer = new int[obj.m_length];
        
        if( pointer )
        {
        /* 复制参数对象中的元素 */
            for(int i=0; i<obj.m_length; i++)
            {
                pointer[i] = obj.m_pointer[i];
            }
            
        /* 深拷贝 */
            m_length = obj.m_length;
            delete[] m_pointer;
            m_pointer = pointer;
        }
    }
    
    return *this;
}

　4，main.cpp 文件：

#include <iostream>
#include <string>
#include "IntArray.h"

using namespace std;

int main()
{
    IntArray* a = IntArray::NewInstance(5);   
    IntArray* b = IntArray::NewInstance(10);
    
    if( a && b )
    {