运算符重载-----实例研究：Array类

说明：在本例中，创建了一个功能强大的数组类Array，它能够进行范围检查，从而确保数组下标保持在有效范围内。这个类允许通过赋值运算符把一个数组对象赋值给另一个数组对象。

//Array.h
#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED

#include<iostream>
using namespace std;

class Array
{
    friend  ostream &operator<<(ostream &,const Array &);
    friend  istream &operator>>(istream &, Array &);
public:
    Array(int = 10);//默认构造函数，有一个带默认值的整型参数
    Array(const Array &);//拷贝构造函数，const的引用；如Array a2(a1);a1仅仅是用一下，所以用const;
    ~Array();//析构函数,此类中有必要的操作。
    int getSize() const;//返回数组长度

    const  Array &operator=(const Array &);//赋值运算符重载
    bool operator==(const Array &) const;
    bool operator!=(const Array &right ) const
    {
       return !(*this == right);//调用等于的情况，
    }

    int &operator[]( int );
    int operator[]( int ) const;
private:
    int size;
    int *ptr;//指向整型数组的指针
};

#endif // ARRAY_H_INCLUDED

//Array.cpp
#include<iostream>
using namespace std;

#include<iomanip>
using std::setw;

#include<cstdlib>
using std::exit;

#include "Array.h"

Array::Array( int arraySize )//如 Array a1(5);
{
     size = (arraySize > 0 ? arraySize : 10);//判断size的值是不是大于0；
     ptr = new int[size];//开辟一个整型数组，首地址给ptr;

     for(int i = 0;i < size;i++)
          ptr[i] = 0;//5个元素的初值给的都是0；
}

Array::Array(const Array &arrayToCopy )//拷贝构造函数，如Array a2(a1);用已有的a1对象初始化a2对象。
:size(arrayToCopy.size)//成员初始化器初始化a2的size;
{
     ptr = new int[size];//给a2开辟一个整型数组，指向ptr,长度为a1的长度。

     for(int i = 0;i < size ;i++)
          ptr[i] = arrayToCopy.ptr[i];//给数组的每个元素初始化值都为a1的值；
}

Array::~Array()//如果不提供析构函数，系统也能使用默认的析构函数回收数组对象，但对于new开辟的空间不能被回收。
{
     delete [] ptr;//显式回收开辟的空间。动态回收一定要在析构函数中，因为开辟在构造函数中
}


int Array::getSize() const
{
     return size;//获得数组的长度返回。
}

const Array &Array::operator=(const Array &right)//赋值运算符的重载，如a1 = a2；
{
     if(&right != this)//比较两个对象是不是相同，比较其地址；
     {
         if(size != right.size)//比较a1和a2的size是不是一样；
           {
              delete [] ptr;//把a1开辟的空间回收；
              size = right.size;//把a2 size 的大小赋值给a1；
              ptr = new int[size];//把a1重新开辟一块空间和a2一样大；
           }

           for(int i = 0;i < size;i++)
               ptr[i] = right.ptr[i];//把a2的元素依次赋值给a1；
     }
     return *this;//返回被a2赋值后的a1；
     /*此时用户抓住了a1的使用权，但开头有const限制，所以避免了(a1 = a2) = a3的操作。*/
}

bool Array::operator==(const Array &right) const//判断两数组是不是一样运算符的重载；
{
     if(size != right.size)//如果两个长度不一样
          return false;

     for(int i = 0;i < size;i++)
     {
          ptr[size] != right.ptr[size];//依次比较每个元素是不是一样；
     }
     return false;

     return true;
}

int &Array::operator[](int subscript)//取数组元素运算符的重载，如a[2]
{
     if(subscript < 0 || subscript >= size)//如果输入的数组下标不符合，直接错误。
     {
          cerr << "\nError:subscript " << subscript
           << "out of range " << endl;
           exit(1);
     }

     return ptr[subscript];//否则直接返回ptr数组对应德下标。
}//返回的是引用，其实是返回的地址的操作权能够被掌握。即可以做该操作：a[3] = 10;

int Array::operator[]( int subscript ) const//const版本返回的没有引用，
{
       if(subscript < 0 || subscript >= size)//如果输入的数组下标不符合，直接错误。
     {
          cerr << "\nError:subscript " << subscript
           << "out of range " << endl;
           exit(1);
     }

     return ptr[subscript];//否则直接返回ptr数组对应德下标。
}//const对象调用const函数，即 const对象不能被修改，如a[3] = 10错误。

istream &operator>>(istream &input,Array &a)//输入运算符重载；
{
     for(int i = 1;i < a.size;i++)
     {
          input>>a.ptr[i];//依次输入
     }

     return input;
}

ostream &operator<<(ostream &output,const Array &a)//输出运算符的重载 ；
{
     int i;
     for(i = 1;i < a.size;i++)
     {
          output << setw(12) << a.ptr[i];//依次输出，宽度为12；

          if((i+1) % 4 == 0)
               output << endl;
     }

     if(i %4 != 0)
          output << endl;

     return output;
}

//ArrayTest.cpp
#include<iostream>
using namespace std;

#include "Array.h"

int main()
{
     Array integers1(7);
     Array integers2;

     cout << "Size of Array integers1 is :"
        << integers1.getSize()
        << "\nArray after initialization :\n" << integers1;

     cout << "\nSize of Array integers2 is :"
        << integers2.getSize()
        << "\nArray after initialization :\n" << integers2;

     cout << "\nEnter 17 integers :" << endl;
     cin>>integers1 >> integers2;//键盘输入17个整数；

     cout << "\nAfter input ,the Arrays contain :\n"
         << "integers1:\n" << integers1
         << "integers2:\n" << integers2;//再次输出integers1和integers2认证；

     cout << "\nEvaluating:integers1 != integers2" << endl;

     if(integers1 != integers2)
          cout << "integers1 and integers2 are not equal" << endl;

     Array integers3(integers1);//拷贝构造函数integers1实例化integers3;

     cout << "\nSize of Array integers3 is "
          << integers3.getSize()
          << "\nArray after initialization:\n" << integers3;//测试integers3是不是和integers1一样

     cout << "\nAssigning integers2 to integers1:" << endl;
     integers1 = integers2;//赋值操作

     cout << "integers1:\n" << integers1
          << "integers2:\n" << integers2;//输出看是不是相等。

     cout << "\nEvaluating:integers1 == integers2" << endl;
     if(integers1 == integers2)
          cout << "integers1 and integers2 are equal" << endl;

     cout << "\nintegers1[5] is " << integers1[5];//取integers1第5个元素

     cout << "\n\nAssigning 1000 to integers1[5]" << endl;
     integers1[5] = 1000;
     cout << "integers1:\n" << integers1;//非const，左值可以修改

     cout << "\nAttempt to assign 1000 to integers1[15]" << endl;
     integers1[15] = 1000;//下标越界，结束；

     return 0;
}

运行结果展示：