C++ 运算符重载函数和实现

下面代码：

/// Vector 声明头文件 ///
#ifndef Vector_h // 条件预编译
#define Vector_h
#include <iostream>
using namespace std;
class Vector
{
public:
	Vector();
	Vector(int _size, int* _rep);
	~Vector();
	void setRep(int* _rep, int _size);


	friend ostream& operator << (ostream& out, const Vector& p);  // 输出符号重载函数
	friend bool operator == (const Vector& v, const Vector& t); // ==运算符重载


	Vector& operator = (const Vector& v); // =运算符重载,成员函数
private:
	int size;
	int* rep; // 指针
};
#endif


/// Vector 实现文件 ///
#include "Vector.h"
Vector::Vector() :size(0), rep(new int[4]) // 创建一个4个字节的空间，用来初始化rep
{
	*rep = 0; // 将rep置为0值
}


Vector::Vector(int _size, int* _rep) :size(_size), rep(new int[_size])  // 调用的时候给多少空间就开多少空间 
{
	cout << "带参数构造函数" << endl;  // 测试使用的
	for (int i = 0; i < size; i++)
	{
		rep[i] = _rep[i]; // 将传递过来的元素一一赋值
	}
}


Vector::~Vector()
{
	if (rep != NULL) // 1.实现要先判断rep空间是不是为空，如果不为空才进行下一步的删除
	{
		delete[]rep; // 2.将rep所占用的空间释放
		rep = NULL; // 3.并且对rep进行置为空指针
		cout << "Delete rep!" << endl; // 测试使用的
	}
	cout << "~Vector()" << endl; // 测试使用的
}


void Vector::setRep(int* _rep, int _size)
{
	// 这样就是深拷贝
	// 先对原先的空间进行释放
	delete[]rep;
	// 再开辟和原来一样大小的空间
	rep = new int[_size];
	// 然后再进行赋值
	for (int i = 0; i < _size; i++)
	{
		rep[i] = _rep[i];
	}
}


ostream& operator << (ostream& out, const Vector& p)
{
	for (int i = 0; i < p.size; i++)
	{
		out << p.rep[i] << " ";
	}
	return out;
}


Vector& Vector::operator = (const Vector& v)
{
	// 赋值重载运算符（深拷贝）
	// 1.判读是否是自赋值
	if (this != &v)
	{
		delete[]rep; // 2.删除旧空间
		rep = new int[v.size]; // 3.创建新的空间
		size = v.size;  // 需要获取元素个数
		// 4.传递内容
		for (int i = 0; i < size; i++)
		{
			rep[i] = v.rep[i];
		}
	}
	// 5.返回自身
	return *this;
}


bool operator == (const Vector& v, const Vector& t)
{
	bool y = true;
	if (v.size != t.size) // 先对其元素个数进行比较
		y = false;
	else // 下面是元素个数相同的情况下的
	{
		for (int i = 0; i < v.size; i++) // 再进行循环判断每个元素
		{
			if (t.rep[i] != v.rep[i])
			{
				y = false;
				break;
			}
		}
	}
	return y;
}
//  主函数测试 // 
#include "Vector.h"
#include <iostream>
using namespace std;
int main()
{
	int a[4] = { 2, 31, 3, 23 };
	int b[2] = { 22, 33 };
	int c[1] = { 1212 };
	Vector v(4, a);
	//cout<<v<<endl;
	Vector c1(2, b);
	c1 = v; // 将拥有4个数组的a赋值到只有1个数组的c1中
	cout << c1 << endl;


	v.setRep(c, 1);// 是没有改变c1,如果c1改变了值的话，就证明它们的空间是相同的
	cout << c1 << endl; //输出结果是没有改变c1的值的， 这就是证明没有二次删除，并且独立化


	if (c1 == v) // ==运算符重载函数的调用
		cout << "Yes" << endl;
	else 
		cout << "NO" << endl;
	return 0;
}

关于部分运算符重载函数的注意事项

注意一

1. 算数运算符是要使用友元函数，一般不使用成员函数

// Point  类名 实现重载"+"运算符的实现
friend const Point operator + (const Point& p, const Point& p1); 
  const Point operator + (const Point& p, const Point& p1)
{  
    return (p.x + p1.x, p.y + p.y);// x 和 y是Point的数据成员
}

2. 在实现文件中是不需要加friend的，加上的话会报错，
3. const的作用：第一个是修饰的是返回值，防止修改返回值，第二和第三个const是修饰的是常引用，是保护数据的
4. operator是重载关键字
5. 使用常引用的好处就是节省空间

注意二

1. 输出运算符必须要使用友元函数，因为输出运算符输出的第一个是对象，不能使用成员函数来写
2. 必须要有返回值

// Point 为类名 前面不能写const，不然无法进行输入,固定格式 输出运算符常用
friend ostream& operator <<(ostream& out, const Point& p) 
// 实现：
  ostream& operator<<(ostream& out, const Point& p)
{
   return out<<"x = "<<p.x<<"y = "<<p.y<<endl;
}

4. 因为要输出的是私有成员，所以要定义为友元函数并且前面是不能加const关键字的

注意三

1. 下标运算符：必须作为成员函数，因为操作的是一个对象，不能使用成员函数
2. 代码

// 第一种方式 非const方式
 int& operator[](int index) {
     return rep[index]; // rep 是成员数据
}

// 第二种方式 const方式
const int& operator[](int index) const {
     return rep[index];
}

3. 虽然说这两种方式就是多了个const，但是在调用的时候方式是不同的 const方式就是为了防止有const对象来调用，因为const对象是不能调用非const方法的

注意四

1. 赋值运算符重载：必须是成员函数

// Vector 是类名
Vector& operator = (Vector& v) 
// 实现：
Vector& Vector::operator = (Vector& v)
{
  
// 赋值重载运算符（深拷贝）
if (this != &v) // 1.判断是否自赋值
 { 
    delete []rep; // 2.删除旧空间
    rep = new int[v.size];// 3.创建新的空间
    size = v.size;
     // 4.传递内容
    for (int i = 0; i < size; i++)
    {
       rep[i] = v.rep[i];
    }
 }
  // 返回自身
  return *this;
}

​