符号重载函数

最新推荐文章于 2022-04-20 10:55:06 发布
转载 最新推荐文章于 2022-04-20 10:55:06 发布 · 575 阅读 · 0

本文介绍了一个使用C++实现的复数类，该类通过运算符重载实现了与double类型数据之间的加、减、乘、除运算。通过具体的代码示例展示了如何定义这些运算，并提供了测试函数来验证其正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


  1. /* 
  2. *Copyright(c) 2016.烟台大学计算机与控制工程学院 
  3. *ALL rights  reserved. 
  4. *文件名称：test.cpp 
  5. *作者：隋宗涛 
  6. *完成日期：2016年5月14日 
  7. *问题描述:在(2)的基础上，扩展+、-、*、/运算符的功能，使之能与double型数据进行运算。 
  8.           设Complex c; double d; c+d和d+c的结果为“将d视为实部为d的复数同c相加”，其他-、*、/运算符类似 
  9. */  
  10. #include<iostream>  
  11. using namespace std;  
  12. class Complex  
  13. {  
  14. public:  
  15.     Complex(){real=0;imag=0;}  
  16.     Complex(double r,double i){real=r; imag=i;}  
  17.     friend Complex operator+(Complex &c1,Complex &c2);  
  18.     friend Complex operator+(double d1, Complex &c2);  
  19.     friend Complex operator+(Complex &c1, double d2);  
  20.     friend Complex operator-(Complex &c1,Complex &c2);  
  21.     friend Complex operator-(double d1, Complex &c2);  
  22.     friend Complex operator-(Complex &c1, double d2);  
  23.     friend Complex operator*(Complex &c1,Complex &c2);  
  24.     friend Complex operator*(double d1, Complex &c2);  
  25.     friend Complex operator*(Complex &c1, double d2);  
  26.     friend Complex operator/(Complex &c1,Complex &c2);  
  27.     friend Complex operator/(double d1, Complex &c2);  
  28.     friend Complex operator/(Complex &c1, double d2);  
  29.     void display();  
  30. private:  
  31.     double real;  
  32.     double imag;  
  33. };  
  34. //下面定义成员函数  
  35. //复数相加： (a+bi)+(c+di)=(a+c)+(b+d)i  
  36. Complex operator+(Complex &c1,Complex &c2)  
  37. {  
  38.     Complex c;  
  39.     c.real=c1.real+c2.real;  
  40.     c.imag=c1.imag+c2.imag;  
  41.     return c;  
  42. }  
  43. Complex operator+(double d1, Complex &c2)  
  44. {  
  45.     Complex c(d1,0);  
  46.     return c+c2;  
  47. }  
  48. Complex operator+(Complex &c1, double d2)  
  49. {  
  50.    Complex c(d2,0);  
  51.     return c1+c;  
  52. }  
  53. //复数相减： (a+bi)-(c+di)=(a-c)+(b-d)i  
  54. Complex operator-(Complex &c1,Complex &c2)  
  55. {  
  56.     Complex c;  
  57.     c.real=c1.real-c2.real;  
  58.     c.imag=c1.imag-c2.imag;  
  59.     return c;  
  60. }  
  61. Complex operator-(double d1, Complex &c2)  
  62. {  
  63.     Complex c(d1,0);  
  64.     return c-c2;  
  65. }  
  66. Complex operator-(Complex &c1, double d2)  
  67. {  
  68.    Complex c(d2,0);  
  69.     return c1-c;  
  70. }  
  71. //复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i  
  72. Complex operator*(Complex &c1,Complex &c2)  
  73. {  
  74.     Complex c;  
  75.     c.real=c1.real*c2.real-c1.imag*c2.imag;  
  76.     c.imag=c1.imag*c2.real+c1.real*c2.imag;  
  77.     return c;  
  78. }  
  79. Complex operator*(double d1, Complex &c2)  
  80. {  
  81.     Complex c(d1,0);  
  82.     return c*c2;  
  83. }  
  84. Complex operator*(Complex &c1, double d2)  
  85. {  
  86.    Complex c(d2,0);  
  87.     return c1*c;  
  88. }  
  89.   
  90. //复数相除：(a+bi)/(c+di)=(ac+bd)/(c*c+d*d) +(bc-ad)/(c*c+d*d)i  
  91. Complex operator/(Complex &c1,Complex &c2)  
  92. {  
  93.     Complex c;  
  94.     c.real=(c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);  
  95.     c.imag=(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);  
  96.     return c;  
  97. }  
  98. Complex operator/(double d1, Complex &c2)  
  99. {  
  100.     Complex c(d1,0);  
  101.     return c/c2;  
  102. }  
  103. Complex operator/(Complex &c1, double d2)  
  104. {  
  105.    Complex c(d2,0);  
  106.     return c1/c;  
  107. }  
  108.  void Complex::display()  
  109. {  
  110.     cout<<"("<<real<<","<<imag<<"i)"<<endl;  
  111. }  
  112. //下面定义用于测试的main()函数  
  113. int main()  
  114. {  
  115.     Complex c1(3,4),c2(5,-10),c3;  
  116.     double d;  
  117.     cout<<"c1=";  
  118.     c1.display();  
  119.     cout<<"c2=";  
  120.     c2.display();  
  121.     cout<<"请输入实数:";  
  122.     cin>>d;  
  123.     cout<<"d="<<d<<endl<<endl;  
  124.     c3=c1+c2;  
  125.     cout<<"c1+c2=";  
  126.     c3.display();  
  127.     cout<<"c1+d=";  
  128.     (c1+d).display();  
  129.     cout<<"d+c1=";  
  130.     (d+c1).display();  
  131.     c3=c1-c2;  
  132.     cout<<"c1-c2=";  
  133.     c3.display();  
  134.     cout<<"c1-d=";  
  135.     (c1-d).display();  
  136.     cout<<"d-c1=";  
  137.     (d-c1).display();  
  138.     c3=c1*c2;  
  139.     cout<<"c1*c2=";  
  140.     c3.display();  
  141.     cout<<"c1*d=";  
  142.     (c1*d).display();  
  143.     cout<<"d*c1=";  
  144.     (d*c1).display();  
  145.     c3=c1/c2;  
  146.     cout<<"c1/c2=";  
  147.     c3.display();  
  148.     cout<<"c1/d=";  
  149.     (c1/d).display();  
  150.     cout<<"d/c1=";  
  151.     (d/c1).display();  
  152.     return 0;  
  153. }  
  154. /*
*Copyright(c) 2016.烟台大学计算机与控制工程学院
*ALL rights  reserved.
*文件名称：test.cpp
*作者：杨驰
*完成日期：2016年5月14日
*问题描述:在(2)的基础上，扩展+、-、*、/运算符的功能，使之能与double型数据进行运算。
          设Complex c; double d; c+d和d+c的结果为“将d视为实部为d的复数同c相加”，其他-、*、/运算符类似
*/
#include<iostream>
using namespace std;
class Complex
{
public:
    Complex(){real=0;imag=0;}
    Complex(double r,double i){real=r; imag=i;}
    friend Complex operator+(Complex &c1,Complex &c2);
    friend Complex operator+(double d1, Complex &c2);
    friend Complex operator+(Complex &c1, double d2);
    friend Complex operator-(Complex &c1,Complex &c2);
    friend Complex operator-(double d1, Complex &c2);
    friend Complex operator-(Complex &c1, double d2);
    friend Complex operator*(Complex &c1,Complex &c2);
    friend Complex operator*(double d1, Complex &c2);
    friend Complex operator*(Complex &c1, double d2);
    friend Complex operator/(Complex &c1,Complex &c2);
    friend Complex operator/(double d1, Complex &c2);
    friend Complex operator/(Complex &c1, double d2);
    void display();
private:
    double real;
    double imag;
};
//下面定义成员函数
//复数相加： (a+bi)+(c+di)=(a+c)+(b+d)i
Complex operator+(Complex &c1,Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;
    return c;
}
Complex operator+(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c+c2;
}
Complex operator+(Complex &c1, double d2)
{
   Complex c(d2,0);
    return c1+c;
}
//复数相减： (a+bi)-(c+di)=(a-c)+(b-d)i
Complex operator-(Complex &c1,Complex &c2)
{
    Complex c;
    c.real=c1.real-c2.real;
    c.imag=c1.imag-c2.imag;
    return c;
}
Complex operator-(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c-c2;
}
Complex operator-(Complex &c1, double d2)
{
   Complex c(d2,0);
    return c1-c;
}
//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i
Complex operator*(Complex &c1,Complex &c2)
{
    Complex c;
    c.real=c1.real*c2.real-c1.imag*c2.imag;
    c.imag=c1.imag*c2.real+c1.real*c2.imag;
    return c;
}
Complex operator*(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c*c2;
}
Complex operator*(Complex &c1, double d2)
{
   Complex c(d2,0);
    return c1*c;
}

//复数相除：(a+bi)/(c+di)=(ac+bd)/(c*c+d*d) +(bc-ad)/(c*c+d*d)i
Complex operator/(Complex &c1,Complex &c2)
{
    Complex c;
    c.real=(c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}
Complex operator/(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c/c2;
}
Complex operator/(Complex &c1, double d2)
{
   Complex c(d2,0);
    return c1/c;
}
 void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
//下面定义用于测试的main()函数
int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    double d;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    cout<<"请输入实数:";
    cin>>d;
    cout<<"d="<<d<<endl<<endl;
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    cout<<"c1+d=";
    (c1+d).display();
    cout<<"d+c1=";
    (d+c1).display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    cout<<"c1-d=";
    (c1-d).display();
    cout<<"d-c1=";
    (d-c1).display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    cout<<"c1*d=";
    (c1*d).display();
    cout<<"d*c1=";
    (d*c1).display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    cout<<"c1/d=";
    (c1/d).display();
    cout<<"d/c1=";
    (d/c1).display();
    return 0;
}

运行结果：


文章列表
suizongtao
关注
运算符重载（运算符函数）
Jibeon的学习之路
06-17 1613
重载 在同一个作用域内的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。 重载指多个函数或方法具有相同的名称、不同的参数列表和定义。 调用一个重载函数或重载运算符时，编译器把所使用的的参数类型与定义中的参数类型进行比较，决定选用最合适的定义，被称为重载决策。 运算符重载 重载的运算符是电邮特殊名称的函数，函数名是关键字operator和其后要重载的运算符符号构成的。所以，运算符重载是...
C++运算符重载函数
y2zaijian的博客
05-27 666
运算符重载 C++为了增强代码的可读性, 让自定义类型可以直接使用运算符计算, 就需要运算符重载, 运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 1. 定义: 函数名字为：关键字operator后面接需要重载的运算符符号。 函数原型：返回值类型 operator操作符(参数列表) 2. 注意： 自定义类型是不能直接使用运算符计算 基本类型可以 不能通过连接其他符号来创建新的操作符, 只能是语法支持的：比如operator@就不行
函数重载 函数符号生成规则
LMW1150999580的博客
11-27 440
函数的默认值 sum（int a, int b, int c = 10） ①自右向左， 依次赋值。 ②同一个形参只能赋一次。 3，一般会在声明上给出默认值。 4，不能让编译器产生二义性，重载决议不能产生二义性。 5，函数重载不依赖返回值。 三要素：1，同作用域才能重载。               2，同名               3，参数不同 函数符号生成规则 C++ 1...
C++函数运算符重载
程序员的规则
11-20 5295
1、函数符号为什么要重载？ 答：运算符重载就是赋予运算符多重含义。C++通过重新定义运算符，使它能够用于特定类的对象执行特定的操作(不然只能用于对基本类型的常量或变量之间的运算，而不能用于对象之间的运算)，这便增强了C++语言的扩充能力。 2、哪些运算符需要重载，哪些不需要重载？ 答：可以重载的运算符： 算术运算符：+,-,*,/,%,++,–; 位操作运算符：&,|,~,^,＜＜,＞＞ 逻辑运算符：!,&&,||; 比较运算符：＜,＞,＞=,＜=,==,!=; 赋值运算符：=,+
符号重载函数 友元函数
suizongtao的博客
06-15 357
 /* *Copyright(c) 2016.烟台大学计算机与控制工程学院 *ALL rights  reserved. *文件名称：test.cpp *作者：隋宗涛*完成日期：2016年5月14日 *问题描述:请用类的友元函数，定义复数类重载运算符+、-、*、/，使之能用于复数的加减乘 */  #include  using namespace std;  class Complex 
符号重载
HBI_flight的博客
04-25 1272
运算符重载时要遵循以下规则： (1) 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，C++中的所有运算符都可以重载。   (2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。   (3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
详解C++ 重载运算符和重载函数
08-18
C++ 重载运算符和重载函数 C++ 编程语言中，重载运算符和重载函数是两个非常重要的概念。它们允许在同一个作用域中，指定多个定义，分别称为函数重载和运算符重载。 函数重载是指在同一个作用域内，声明多个同名...
C_C++函数符号生成规则（函数名的修饰）；C++ 函数重载.pdf
09-30
本文主要介绍了C和C++函数符号生成规则，以及C++函数重载机制。 一、C函数符号生成规则 在C语言中，函数符号生成规则主要有三种：cdecl调用约定、std call调用约定和fastcall调用约定。 1. cdecl调用约定：函数名...
重载函数的理解
09-27
### 重载函数的理解 #### 一、重载函数的概念 重载函数是C++语言中的一个重要特性，它允许在同一个作用域内定义多个同名函数，这些函数可以通过不同的参数列表来区分。重载函数提高了代码的复用性和可读性，同时也...
cpp代码-C++符号重载
07-16
符号重载有两种形式：成员函数和友元函数。成员函数形式的操作符重载通常作为类的成员，而友元函数形式则作为非成员函数，但与类有特殊的关系。 1. **成员函数形式的符号重载**： 当操作符的一个操作数是被重载...
关于函数运算符号重载函数
weixin_30659829的博客
04-07 105
class A{public: typedef int (*func)(int); operator func();};int ff(int a){ return a;}A::operator func(){ return ff;}int main () { cout<< A::func(9)<<endl;//运算符号 func（） 这个fun...
函数重载和重载运算符
weixin_30394981的博客
08-01 241
#include<iostream> using namespace std; class Box{ private: int width; int height; public: Box(int w,int h){ width=w; height=h; }; Box(){ }; //重载函数 void getWidth(){ cout&l...
C++ 符号重载
m0_37579906的博客
08-25 7092
符号重载:c++符号增加支持自定类型的操作数.实际是一个特殊函数.函数名为:operator 符号   c++ 支持可重载符号:   算术运算符：+,-,*,/,%,++,--   位操作运算符：&amp;,|,~,^,＜＜,＞＞   逻辑运算符：!,&amp;&amp;,||;   比较运算符：＜,＞,＞=,＜=,==,!=;   赋值运算符：=,+=,-=,*=,/=,%=,&am...
函数重载/运算符重载
cuc_pyx技术小站
07-05 602
函数重载 函数名相同，但函数类型、参数类型及个数不完全相同。本质上还是不同的函数，只不过方便记忆。 int add(int a, int b) { return a+b; } double add(double a, double b) { return a+b; } int add(int a, int b, int c) { return a+b+c; } 多种构造函数均以类名为函数名（无参构造函数、有参构造函数、拷贝构造函数），但它们的参数不同，所以本质上也是函数重载。 运算
运算符重载函数
weixin_47020721的博客
12-21 1661
1、“=”赋值运算符重载————解决指针悬挂问题 说明：类的赋值运算符“=”只能重载为成员函数，而不能把它重载为友元函数 class STRING { public: STRING &operator=(const STRING &); private: char *ptr; }; STRING &STRING::operator(const STRING &s) {if(this==&s) return *this;//防止s=s的赋值 delete ptr; pt
符号的重载实例
diyhoo的编程小屋
05-13 499
complex.h#ifndef H_complexnumber #define H_complexnumber #include&lt;iostream&gt; using namespace std; class complexType { friend ostream&amp; operator&lt;&lt;(ostream&amp;, const complexType&amp;); ...
函数调用符（）重载及总结
Dawn_di的博客
03-23 268
函数调用符（）重载 为了优化类成员函数的调用，对函数调用符（）进行重载 #include <iostream> using namespace std; class Fun { public: int my_add(int x,int y) { return x+y; } //重载() //第一个()是重载的符号 第二个（）是标...
重载符号函数之析构函数
qq_51802524的博客
04-20 411
题目要求：编写一个矩阵类，通过成员函数重载运算符实现矩阵的加法，数乘，乘法。 大家不用看具体的代码实现，主要关注的是重载运算符和析构函数部分，这是我想表达的重点。 代码1： #include <iostream> using namespace std; static int counts = 0; class Matrix { private: int row; int column; int *matrix; public: Matrix(){
c++符号重载函数
最新发布
04-19
### C++ 中符号重载函数的使用方法 在 C++ 中，运算符重载是一种允许自定义类支持特定操作的功能。通过运算符重载，可以使用户定义类型的对象像内置类型一样参与表达式的计算。以下是有关如何实现和使用符号重载函数的一些关键点。 #### 运算符重载的基础概念 C++ 支持多种运算符的重载，包括但不限于加法 (`+`)、减法 (`-`)、赋值 (`=`) 和流插入/提取运算符 (`<<` / `>>`) 等。需要注意的是，并非所有的运算符都可以被重载，例如范围运算符 (`::`) 或成员访问运算符（`.`）。此外，某些运算符只能作为成员函数进行重载，而另一些则既可以作为成员函数也可以作为全局函数来实现[^1]。 #### 实现方式 运算符可以通过两种方式进行重载： 1. **作为类的成员函数**：这种方式适用于那些需要访问私有数据成员的操作。 2. **作为友元 (friend) 函数**：当涉及两个不同类型的对象之间的操作时，通常会采用这种方法。 下面是一个简单的例子展示如何重载加法运算符： ```cpp #include <iostream> using namespace std; class Complex { private: double real; double imag; public: Complex(double r = 0, double i = 0) : real(r), imag(i) {} // 成员函数形式的运算符重载 Complex operator+(const Complex& c) const { return Complex(real + c.real, imag + c.imag); } friend ostream& operator<<(ostream& os, const Complex& c); }; // 友元函数形式的运算符重载 ostream& operator<<(ostream& os, const Complex& c) { os << c.real << " + " << c.imag << "i"; return os; } int main() { Complex c1(3, 7), c2(2, 5); Complex result = c1 + c2; // 调用了 member function 的 operator+ cout << "Result: " << result << endl; // 调用了 friend function 的 operator<< return 0; } ``` 在这个示例中，展示了如何通过成员函数的方式重载加法运算符以及通过友元函数的形式重载流插入运算符[^1]。 #### 特殊情况处理 对于一些特殊的运算符，比如赋值运算符 (`=`)，它一般是以成员函数的形式存在并返回当前对象的引用以便链式赋值能够正常工作。另外，在设计拷贝控制机制的时候也需要特别注意深浅复制的问题。 #### Qt中的应用扩展 除了标准库之外，在框架如Qt里也有广泛的应用场景。例如利用 QOverload 来解决信号槽机制下的多重载问题。这使得即使面对复杂的继承关系或者模板泛型编程也能清晰明了地指定期望的行为模式而不至于引起歧义错误[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值