# 运算符重载

1.  双目运算符类成员函数重载

#include<iostream>
using namespace std;
class complex {
double real, imag;
public:
complex(double r = 0, double i = 0) { real = r; imag = i; }
complex operator + (complex&);  //运算符重载的成员函数原型
//运算符结果类型 operator @(参数表列);  其中，@表示运算符
void print();
};
/*运算符重载实现：

{
//代码
}*/
complex  complex::operator+(complex& c) {  //operator+ 是类complex的成员函数
complex sum;
sum.real = real + c.real;
sum.imag = imag + c.imag;
return sum;
}
void complex::print() {
cout << "real=" << real << endl;
cout << "imag=" << imag << endl;
}
void main() {
complex  a(5.0, 6.0), b(4.0, 5.0);
complex  c;
c = a + b;
//c=5+a;
c.print();
}

（1）带参构造函数，实现给数据成员赋初值；

（2）重载运算符==，实现对象比较（如果两个people类对象的身份证id相等，则结果为1，否则结果为0）。

#include <iostream>
#include <cstring>
using namespace std;
class people
{
private:
string name;
string id;
public:
people(string name_1, string id_1)
{
name == name_1;
id = id_1;
}
bool operator==(people& p);//重载的成员函数声明
};
bool people::operator==(people& p)
{
if (id == p.id)
return 1;
return 0;
}
int main()
{
people p1("HUAHUA", "123432"), p2("HUGFFY", "234143");
cout << "nanaa:" << "123432" << endl;
cout << "lili:" << "234143" << endl;
if (p1 == p2)
{
cout << "ID相等." << endl;
}else
cout << "ID不相等！" << endl;

return 0;
}

bool是布尔型变量，也就是逻辑型变量的定义符，类似于float、double等。bool为布尔型用作逻辑判断，bool取值false和true，是0和1的区别；false可以代表0，但true有很多种，并非只有1。

2、双目运算符的非成员函数的重载

class  complex;//需要类的原型声明 VC++编辑器需要
complex  operator+(int, complex);//需要友元普通函数声明VC++编辑器需要
class complex {
private:
double real, imag;
public:
complex(double r = 0, double i = 0) { real = r; imag = i; }
friend  complex operator + (int, complex);  //运算符重载普通友元函数原型
//函数返回值类型 friend operator @(参数表列); 其中@表示运算符
void print();
};
/*运算符重载普通友元函数实现部分格式：

complex operator +(int c, complex d) {
complex sum;
sum.real = c + d.real;//c = 5+ b;整数+复数
sum.imag = d.imag;
return sum;
}

class people
{
private:
string name;
string id;
public:
people(string name_1, string id_1)
{
name == name_1;
id = id_1;
}
friend bool operator==(people& p3, people& p);
};
bool operator==(people& p3, people& p)
{
if (p3.id == p.id)
return 1;
return 0;
}


3、单目运算符的重载

#include<iostream>
using namespace std;
class complex {
private:
double real, imag;
public:
complex(double r = 0, double i = 0) { real = r; imag = i; }
complex& operator++();  //前缀形式原型
complex  operator++(int);  //后缀形式原型
void print();
};
complex& complex::operator++() {//前缀形式定义
++real;
++imag;
return (*this);
}
complex complex::operator++(int c) {//后缀形式定义
complex temp = *this;
++real;
++imag;
return temp;
}
void complex::print() {
cout << "real=" << real << endl;
cout << "imag=" << imag << endl;
}
void main() {
complex a(5.0, 6.0), b(4.0, 5.0);
complex c, d, f, g;
f = ++c; //等价形式c.operator++();
g = d++; //等价形式d.operator++(0);
f.print();
g.print();
}

++前缀运算符的重载原型（++a，a为对象）

complex& operator++(); //前缀形式原型

++后缀运算符重载原型（a++，a为一个对象）

complex operator++(int); //后缀形式  原型

例：编程：

#include <iostream>
using namespace std;

class Point {
public:
Point() { }
Point(int _x, int _y);
~Point() { }
Point& operator++();//对应于a++
Point& operator--();//对应于a--
Point operator++(int);//对应于a++
Point operator--(int);//对应于a--
void print();
private:
int x;
int y;
};

Point::Point(int _x, int _y) {
x = _x;
y = _y;
}

Point& Point::operator++() {//++a
x++;
y++;
return *this;
}

Point Point::operator++(int) {//a++
Point p=* this;
++(*this);
return p;
}

Point& Point::operator--() {//--a
x--;
y--;
return *this;
}

Point Point::operator--(int) {//a--
Point p=*this;
--(*this);
return p;
}
void Point::print()
{
cout << "(" << x << "," << y << ")" << endl;
}
int main()
{
Point a(3,5);
a.print();
cout << endl;
(a++).print();//测试后置++
a.print();
cout << endl;
(++a).print();//测试前置++
a.print();
cout << endl;
(a--).print();//测试后置--
a.print();
cout << endl;
(--a).print();//测试前置--
a.print();
return 0;
}

4编程：定义一个矩阵类Matrix

class Matrix  {  //定义Matrix类

public:

int &operator [] (  int i  );   //重载下标运算符[]

void input();               //输入数据函数

void display();             //输出数据函数

private:

int mat[5];

};

input函数实现对数据成员mat数组的输入，display函数实现对数据成员mat的输出。重载运算符[ ]，取得数据成员mat指定下标的元素值，比如：

Matrix m;

cout<<m[2];  //取得数据成员mat中，下标为2的值

#include<iostream>
#include<iostream>
using namespace std;

class Matrix {  //定义Matrix类
public:
int& operator [] (int i);   //重载下标运算符[]
void input();               //输入数据函数
void display();             //输出数据函数
private:
int mat[5];
};
void Matrix::input() {
for (int i = 0; i < 5; i++)
{
cout << "输入第" << i << "个元素：";
cin >> mat[i];
}
}
void Matrix::display() {
for (int i = 0; i < 5; i++)
{
cout << mat[i] << " ";
}
}
int& Matrix::operator[](int i) {
return  this->mat[i];
}
void main() {
Matrix m;
m.input();
m.display();
cout << "Mat[2]=";
cout << m[2];
}

1. 将复数的加减法这样的运算重载为类的成员函数，除了使用了关键字operator外，运算符重载成员函数与类的普通成员函数没有什么区别。

2. 使用友元函数。即运算符重载为非成员函数

3. 一般在C++中只要定义非成员函数，就使用友元函数。（可以访问私有成员）

4. 单目运算符分为前置++和后置++。所以规定：对于前置单目运算符，重载函数没有形参；对于后置单目运算符，重载函数有一个int型形参。

posted @ 2019-11-30 17:26  nanaa  阅读(360)  评论(0编辑  收藏  举报