菜鸟学习历程【29】运算符重载

我们知道，函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。

那么对于运算符而言，也可以重载实现不同的功能。

不可重载的运算符有（用括号括起来）： （.），（：：），（.*），（？：），（sizeof）

不可使用友元函数重载的有： = 、 （） 、 【】、 ->

对于无法修改左操作数的时候，只能使用全局函数实现。

双目运算符

以“+”运算符为例

//对于两个整型变量a, b
//定义 int c = a + b;编译器很容易去理解，但对于两个复数类的对象，编译器并不知道，该如何对这种情况进行相加，因此，我们需要重载“+”运算符。
#include <iostream>

using namespace std;

class Complex
{
public:
Complex(int a, int b)
{
m_a = a;
m_b = b;
}
Complex operator+(const Complex &obj) const
{
Complex tmp(m_a + obj.m_a, m_b + obj.m_b);

return tmp;
}
void print()
{
printf("%d + %di\n", m_a, m_b);
}
private:
int m_a; //实部
int m_b; //虚部
};

int main()
{
Complex c1(1, 2);
c1.print(); // 1 + 2i

Complex c2(2, 3);
c2.print(); // 2 + 3i

Complex c3;
//运算符重载的步骤
//1.写出函数名： operator + 要重载的运算符；例如： operator+
//2.根据运算符需要的操作数个数写出参数列表，例如：operator+(c1, c2)
//3.根据需要，写出函数返回值：Complex operator+(const Complex &c1, const Complex &c2)
//写成内部：Complex operator+(const Complex &obj) const
//写成类的成员函数与写成全局函数，只能有一个存在
c3 = c1 + c2;
return 0;
}

单目运算符

以前置 ++ 和后置 ++ 为例

我们想通过对类的成员进行 ++ 操作时，对实部与虚部都进行 ++ 操作，因此需要重载这种运算符。

#include <iostream>

using namespace std;

class Complex
{
//外部实现时，需声明为友元函数才行
friend Complex& operator++(Complex &obj);
public:
Complex(int a, int b)
{
m_a = a;
m_b = b;
}
//前置++,内部实现比外部实现少一个参数，因为内部非静态函数内有this指针，指向当前对象
Complex& operator++()
{
++m_a;
++m_b;
return *this;
}
//后置++，为了与前置++进行区分，会使用一个占位参数
Complex operator++(int)
{
Complex tmp(m_a, m_b);
m_a++;
m_b++;
return tmp;
}
void print()
{
printf("%d + %di\n", m_a, m_b);
}
private:
int m_a; //实部
int m_b; //虚部
};

//前置++
//外部实现与内部实现，只允许一个存在
//Complex& operator++(Complex &obj)
//{
//  ++obj.m_a;
//  ++obj.m_b;
//  return obj;
//}

int main()
{
Complex c1(1, 2);
++c1;
c1.print();  // 2 + 3i
Complex c2 = c1++;
c2.print();  // 2 + 3i
c1.print();  // 3 + 4i
return 0;
}

函数运算符（）

#include <iostream>

using namespace std;

class Test
{
public:
Test(int a)
{
this->a = a;
}

void operator()(int b1, int b2)
{
printf ("a = %d\n", a);
}
private:
int a;
};

int main7_1()
{
// 定义对象
Test a(10);

// ()是函数调用运算符
// operator()(Test &a)  ===>   operator()()
a(1, 2);  // a 是一个对象， 不是一个函数， 但是它的行为和函数很像, 这样的使用  叫仿函数

return 0;
}

左移与右移运算符

输入输出运算符，只能对一些基本数据类型进行直接的操作，从键盘直接输入一个整型数、输入一个字符、字符串。。。。

如果让它输入输出一个自定义类型的数据，编译无法通过，所以需要重载来完成。

例如，我们通过左移运算符直接输出一个复数类的对象。

#include <iostream>

using namespace std;

class Complex
{
friend ostream& operator<<(ostream &out,const Complex &obj);
public:
Complex(int a, int b)
{
m_a = a;
m_b = b;
}
void print()
{
printf("%d + %di\n", m_a, m_b);
}
private:
int m_a; //实部
int m_b; //虚部
};

ostream& operator<<(ostream &cout,const Complex &obj)
{
out << obj.m_a << " + " << obj.m_b << "i";
return out;
}

int main()
{
Complex c1(1, 2);
//左移运算符的左操作数是cout，它属于ostream，我们无法修改，所以只能通过友元函数进行实现
// operator<<(ostream &cout,const Complex &obj);
cout<< c1 << endl;

return 0;
}

赋值运算符

#include <iostream>

using namespace std;
class Teacher
{
friend ostream &operator<<(ostream &out, const Teacher &s);
public:
Teacher()
{
age  = 0;
name = NULL;
}
Teacher (int age, char *name)
{
this->age = age;
this->name = new char[20];

strcpy (this->name, name);
}

Teacher (const Teacher &obj)
{
this->age = obj.age;
this->name = new char[20];

strcpy (this->name, obj.name);
}
~Teacher()
{
if (name != NULL)
delete [] name;
name = NULL;
age  = 0;
}

Teacher &operator=(const Teacher &obj)
{
// 函数入口参数检查  如果是自己直接返回
if (&obj == this)
return *this;

// 1、释放原有的空间
if (name != NULL)
delete [] name;

// 2、开辟新空间
this->name = new char[20];

// 复制
this->age = obj.age;
strcpy (this->name, obj.name);

return *this;
}

private:
int age;
char *name;
};

ostream &operator<<(ostream &out, const Teacher &s)
{
printf ("age = %d, name = %s", s.age, s.name);
return out;
}

int main()
{
Teacher t1(20, "wang");

Teacher t2 = t1;
cout << t2 << endl;

Teacher t3(25, "zhang");

// 默认的赋值运算是  一个浅拷贝的过程， 不会复制堆上的空间
t3 = t2;
cout << t3 << endl;

Teacher t4;

t3 = t3;

return 0;
}

数组下标运算符

#include <iostream>

using namespace std;

class Array
{
friend ostream &operator<<(ostream &out, const Array& obj);
public:
Array(int len = 0)
{
m_len = len;
if (len <= 0)
m_array = NULL;

m_array = new int[len];
}
~Array()
{
if (m_array != NULL)
delete[]m_array;
}
Array(const Array &obj)
{
m_len = obj.m_len;
m_array = new int[m_len];

for (int i = 0;i < m_len; i++)
{
m_array[i] = obj.m_array[i];
}
}
int & operator[](int i)
{
return m_array[i];
}
Array & operator=(const Array &obj)
{
for (int i = 0; i < obj.m_len; i++)
{
m_array[i] = obj.m_array[i];
}
}

private:
int m_len;
int *m_array;
};

ostream &operator<<(ostream &out, const Array& obj)
{
for (int i = 0; i < obj.m_len; i++)
{
out << obj.m_array[i] << "  " ;
}

return out;
}

int main()
{
Array a(10);
for (int i = 0; i < 10; i++)
{
a[i] = i;
}

Array a1 = a;

cout <<"a = "<< a << endl;
cout <<"a1 = "<<a1 << endl;

a1[3] = 200;

cout << "a1 = " << a1 << endl;

return 0;
}