运算符重载实例：数组

 

问题：C和C++中数组是一个指针：大小为n的数组下标必须是0、1、2……n-1，下标不允许改变；不能一次输入或者输出数组，只能单独的对数组元素操作；不能用相等运算符或者关系运算符比较数组，因为数组名是指向内存中数组起始位置的指针；传递数组时，数组大小通常也要传递；不能用赋值运算把一个数组赋给另外一个数组，因为数组名是const类型指针，常量指针是不能再赋值运算的左边的。

本例建议一个数组类，实现功能

1.      检测数组下标不会越界

2.      将一个数组赋值给另一个数组

3.      传递数组时，自动知道数组大小，不用传递数组大小

4.      整体输入输出数组

5.      比较数组

 

//头文件array1.h

#ifndef ARRAY1_H
#define ARRAY1_H

#include<iostream.h>

class Array{
 
 //当运算符函数是一个成员函数，最左边操作数必须是运算符类的一个对象（或者其引用）
 //如果左边操作数必须是一个不同类的对象或者一个内部类型对象，那么该函数必须作为一个非成员函数
 //要访问private and protected 数据成员，必须有元
 friend istream &operator>> (istream &, Array &);
 friend ostream &operator<< (ostream &, const Array &);

public:
 Array(int = 10);
 Array( const Array &);
 ~Array();

 int getSize() const;
 //赋值重载
 const Array &operator= (const Array &);
 //比较重载：== 和 !=（!= 用 == 来实现）
 bool operator==(const Array &) const;
 bool operator!=(const Array &) const;

 //操作数组任意元素
 int &operator[]( int );
 const int &operator[] (int) const;

 static int getArrayCount();

private:
 //数组长度
 int size;
 //指向一个数组元素的指针
 int *ptr;
 static int arrayCount;

};

#endif

 

//array.cpp

#include <iostream.h>
#include <iomanip.h>
#include <stdlib.h>
#include <assert.h>

#include "array1.h"

int Array::arrayCount = 0;

Array::Array(int arraySize)
{
 size = (arraySize >0 ? arraySize : 10);
 ptr = new int [size];
 assert (ptr != 0);
 ++arrayCount;

 for (int i = 0; i < size; i ++)
 {
  ptr[i] = 0;
 }
}

Array::Array( const Array &init) : size(init.size)
{
 ptr = new int [size];
 assert(ptr != 0);
 ++arrayCount;
 for(int i = 0; i < size; i++)
  ptr[i] = init.ptr[i];
}

Array::~Array()
{
 delete [] ptr;
 --arrayCount;
}

int Array::getSize() const
{
 return size;
}

const Array &Array::operator = ( const Array &right)
{
 if(&right != this)   //check for self-assignment
 {
  if(size != right.size) 
  {
   delete [] ptr;
   size = right.size;
   ptr = new int[size];
   assert(ptr != 0);
  }
  for(int i = 0; i < size; i++)
   ptr[i] = right.ptr[i];

 }
 return *this;
}

bool Array::operator ==(const Array &right) const
{
 if(size != right.size)
  return false;
 for(int i = 0; i<size; i++)
  if(ptr[i] != right.ptr[i])
   return false;
 return true;

}

bool Array::operator != (const Array &right) const
{
 return !(*this == right);//!!!!
}

//for non-const Array
int &Array::operator[] (int subscript)
{
 assert(0 <= subscript && subscript <= size);
 return ptr[subscript];
}

//for const array

const int &Array::operator[](int subscript) const
{
 assert (0 <= subscript && subscript <= size);
 return ptr[subscript];
}

int Array::getArrayCount() {return arrayCount;}

istream &operator>> (istream &input, Array &a)
{
 for(int i = 0; i < a.size; i++)
  input >> a.ptr[i];
 return input;
}

ostream &operator<< (ostream &output, const Array &a)
{
 int i = 0;
 for (; i < a.size; i++)
 {
  output << setw(12) << a.ptr[i];
  if((i+1)%4 == 0)
   output << endl;
 }

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

 return output;
}

 

//主函数

#include <iostream.h>
#include "array1.h"

int main()
{
 //no object
 cout << Array::getArrayCount() << endl;

 //生成两个对象，调用构造函数
 Array integer1(7), integer2;
 cout << Array::getArrayCount() << endl;

 cout << "the first array: \n" << integer1.getSize() << '\n'
  << integer1 << '\n\n';

 cout << "the second array: \n" << integer2.getSize() << '\n'
  << integer2 << '\n\n';

 cout << "enter 17 integers: ";
 cin >> integer1 >> integer2;

 cout << "after input: \n"<< integer1.getSize() << '\n'
  << integer1 << '\n\n'<< integer2.getSize() << '\n'
  << integer2 << '\n\n';

 //比较两个数组
 if (integer1 != integer2)
 {
  cout << "不相等\n";
 }
 
 // copy
 Array integer3(integer1);
 cout << "the third array: \n" << integer3.getSize() << '\n'
  << integer3 << '\n\n';

 // 赋值
 integer1 = integer2;
 cout << "the first array: \n" << integer1.getSize() << '\n'
  << integer1 << '\n\n';
 
 cout << "the second array: \n" << integer2.getSize() << '\n'
  << integer2 << '\n\n';

 integer1[2] = 1000;
 cout << integer1 << endl;

 //integer1[20] = 1000;

 return 0;
}