运算符重载

#include"iostream.h"

class complex

{

public:

complex(double r=0.0,double i=0.0){real=r;imag=i;}

void display();

private:

double real;

double imag;

};

-real: double

-imag:double

+complex(r:double=0.0,i:double=0.0)

+operator+(c2:complex):complex

+operator-(c2:complex):complex

+display():void

#include"iostream.h"

//using namespace std;

class complex

{

public:

complex(double r=0.0,double i=0.0){real=r;imag=i;}

complex operator +(complex c2);

complex operator -(complex c2);

void display();

private:

double real;

double imag;

};

complex complex::operator +(complex c2)

{

return complex (real+c2.real,imag+c2.imag);

}

complex complex::operator -(complex c2)

{

return complex (real-c2.real,imag-c2.imag);

}

void complex::display() {

cout<<"("<

}

void main()

{complex c1(5,4),c2(2,10),c3;

cout<<"c1=";c1.display();

第五章 多态性

(1)编写一个程序，用成员函数重载运算符“+”和“-”，将两个二维数组相加和相减，要求第一个二维数组的值由构造函数设置，另一个二维数组的值由键盘输入。

#include

using namespace std;

class Matrix

{

public:

Matrix();//加一个这个默认构造函数,设置初值

Matrix(int a[2][3]);//设置数组的构造函数

Matrix operator+(int b[2][3]);//运算符+重载成员函数

Matrix operator-(int b[2][3]);//运算符-重载成员函数

void show();//输出数组和

private:

int p[2][3];//数组

};

Matrix::Matrix()

{

for(int i=0;i<2;i++)

for(int j=0;j<3;j++)

p[i][j]=0;

}

Matrix::Matrix(int a[2][3])

{

for(int i=0;i<2;i++)

for(int j=0;j<3;j++)

p[i][j]=a[i][j];

}

Matrix Matrix::operator+(int b[2][3])

{

Matrix a;

for(int i=0;i<2;i++)

for(int j=0;j<3;j++)

a.p[i][j]=p[i][j]+b[i][j];

return a;

}

Matrix Matrix::operator-(int b[2][3])

{

Matrix c; for(int i=0;i<2;i++)

for(int j=0;j<3;j++)

C++基础系列——运算符重载

1. 运算符重载简介

所谓重载，就是赋予新的含义。函数重载（Function Overloading）可以让⼀个函数名有多种功能，在不同情况下进⾏不同的操作。同样运算符重载（OperatorOverloading）可以让同⼀个运算符可以有不同的功能。

可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符，⼜可以配合 cout 向控制台输出数据

也可以⾃定义运算符重载：class Complex

{

public:

Complex();

Complex(double real, double imag);

Complex operator+(const Complex &a) const;

void display() const;

private:

double m_real;

double m_imag;

};

// ...

// 实现运算符重载

Complex Complex::operator+(const Complex &A) const{

Complex B;

B.m_real = this->m_real + A.m_real;

B.m_imag = this -> m_imag + A.m_imag;

return B;

// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);

}

int main(){

Complex c1(4.3, 5.8);

Complex c2(2.7, 3.7);

Complex c3;

c3 = c1 + c2; // 运算符重载

c3.display();

return 0;

}

运算结果7 + 9.5i

运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。c3 = c1 + c2;

c++ 运算符重载详解

C++ 运算符重载是一种特殊的技术，允许我们自定义操作符来应对不同的数据类型。在 C++ 中，我们可以使用运算符重载来定义自己的数据类型的行为，例如字符串、向量等等。

运算符重载是通过使用特殊的函数来实现的，这些函数命名方式为 "operator+"，其中"+"表示重载的运算符。这些函数与普通函数不同，它们具有特殊的语法和返回值。

例如，我们可以使用运算符重载 '+' 来实现两个自定义类的加法操作。

```c++

class MyClass {

private:

int my_value;

public:

MyClass(int value) : my_value(value) {}

// 运算符重载定义

MyClass operator+(const MyClass& other) const {

return MyClass(my_value + other.my_value);

}

};

int main() {

MyClass first(5);

MyClass second(10);

MyClass result = first + second; // 使用运算符重载

return 0;

}

```

在上述代码中，我们定义了一个 `operator+` 函数，它使用传入的 `MyClass` 对象和当前对象的 `my_value` 属性计算结果。然后我们在 `main()` 函数中使用 `+` 运算符实现两个对象的加法操作。

运算符重载可以让我们的代码更加直观和简洁。请注意，每个运算符都有其特定的语法和行为，因此必须谨慎使用。

如果您想要了解更多有关 C++ 中的运算符重载的详细信息，请阅读相关的 C++ 教程和文档。