下面代码:
/// 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;
}
关于部分运算符重载函数的注意事项
注意一
- 算数运算符是要使用友元函数,一般不使用成员函数
// 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的数据成员
}
- 在实现文件中是不需要加friend的,加上的话会报错,
- const的作用:第一个是修饰的是返回值,防止修改返回值,第二和第三个const是修饰的是常引用,是保护数据的
- operator是重载关键字
- 使用常引用的好处就是节省空间
注意二
- 输出运算符必须要使用友元函数,因为输出运算符输出的第一个是对象,不能使用成员函数来写
- 必须要有返回值
// 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;
}
- 因为要输出的是私有成员,所以要定义为友元函数并且前面是不能加const关键字的
注意三
- 下标运算符:必须作为成员函数,因为操作的是一个对象,不能使用成员函数
- 代码
// 第一种方式 非const方式
int& operator[](int index) {
return rep[index]; // rep 是成员数据
}
// 第二种方式 const方式
const int& operator[](int index) const {
return rep[index];
}
- 虽然说这两种方式就是多了个const,但是在调用的时候方式是不同的 const方式就是为了防止有const对象来调用,因为const对象是不能调用非const方法的
注意四
- 赋值运算符重载:必须是成员函数
// 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;
}