C++编程学习笔记 week9

最新推荐文章于 2022-10-03 11:37:15 发布
最新推荐文章于 2022-10-03 11:37:15 发布
阅读量121 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PattyAndSmith/article/details/83868043
版权

运算符重载

9.1 复数类对象的加法运算-用成员函数

利用成员函数实现复数类对象的加法运算。


#include <iostream>     
using namespace std;  
class complex   //复数类声明  
{  
public: //外部接口  
complex(double r=0.0,double i=0.0)  
{real=r;imag=i;}  
complex add(complex &c);   
  
void Show();      
private:      
    double real;      
    double imag;      
};  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  
complex complex::add(complex &c2)  
{   complex t;  
    t.real=real+c2.real;  
    t.imag=imag+c2.imag;  
    return t;  
}  

int main()     //主函数  
{  
    double a,b,c,d;  
    cin>>a>>b>>c>>d;  
    complex c1(a,b),c2(c,d),c3;  //声明复数类的对象  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();  
    c3=c1.add(c2);  //使用成员函数add完成复数加法  
    cout<<"c3=c1+c2=";  
    c3.Show();  
    return 0;  
}

9.2 复数类对象的加法运算-用友元函数

利用非成员函数，即友元函数实现复数对象的加法运算

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
complex(double r=0.0,double i=0.0)  
{real=r;imag=i;}  
friend complex add(complex &c1,complex &c2);  
  
void Show();      
private:      
    double real;      
    double imag;      
};  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  
complex  add(complex &c1,complex &c2)   
{   complex t;  
    t.real=c1.real+c2.real;  
    t.imag=c1.imag+c2.imag;  
    return t;  
}  

int main()     //主函数  
{  
    double a,b,c,d;  
    cin>>a>>b>>c>>d;  
    complex c1(a,b),c2(c,d),c3;  //声明复数类的对象  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();  
    c3=add(c1,c2);  //使用友元函数add完成复数加法  
    cout<<"c3=c1+c2=";  
    c3.Show();  
    return 0;  
}

9.3 复数类对象的加法运算-运算符重载为成员函数

用+运算符实现复数类对象的加法运算，用重载+运算符为成员函数

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
    complex(double r=0.0,double i=0.0){real=r;imag=i;}  
    complex add(complex &c2);   
    complex operator +(complex &c2);   
    void Show();      
private:      
    double real;      
    double imag;      
};    
  
complex complex::operator +(complex &c2)    
{   complex t;  
    t.real=real+c2.real;  
    t.imag=imag+c2.imag;  
    return t;  
}  
  
  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  
int main()     //主函数  
{  
    double a,b,c,d;  
    cin>>a>>b>>c>>d;  
    complex c1(a,b),c2(c,d),c3;  //声明复数类的对象  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();  
    c3=c1+c2;   //使用重载运算符完成复数加法  
    cout<<"c3=c1+c2=";  
    c3.Show();  
    return 0;  
}

9.4 复数类对象的加法运算-运算符重载为友元函数

用+运算符实现复数类对象的加法运算，用重载+运算符为友元函数

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
    complex(double r=0.0,double i=0.0){real=r;imag=i;}  
      
    friend complex operator +(complex &c1,complex &c2);   
    void Show();      
private:      
    double real;      
    double imag;      
};    
  
complex operator +(complex &c1,complex &c2)    
{   complex t;  
    t.real=c1.real+c2.real;  
    t.imag=c1.imag+c2.imag;  
    return t;  
}  
  
  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  

int main()     //主函数  
{  
    double a,b,c,d;  
    cin>>a>>b>>c>>d;  
    complex c1(a,b),c2(c,d),c3;  //声明复数类的对象  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();  
    c3=c1+c2;   //使用重载运算符完成复数加法  
    cout<<"c3=c1+c2=";  
    c3.Show();  
    return 0;  
}

9.5 复数类对象的++运算-重载++运算符为成员函数

用++运算符实现复数对象的实部加1，用重载++为成员函数。

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
    complex(double r=0.0,double i=0.0){real=r;imag=i;}  
      
    complex operator ++();  
    complex operator ++(int);   
  
    void Show();      
private:      
    double real;      
    double imag;      
};    
  
complex complex::operator ++()    
{   complex t;  
    t.real=real+1;  
    t.imag=imag;  
    real=real+1;  
    imag=imag;  
    return t;  
}  
  
complex complex::operator ++(int)  
{   complex t;  
    t.real=real;  
    t.imag=imag;  
    real=real+1;  
    imag=imag;  
    return t;  
}  
  
  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  


int main()     //主函数  
{  
    double a,b,c,d;  
    cin>>a>>b>>c>>d;  
    complex c1(a,b),c2(c,d);  //声明复数类的对象,c1,c2有参  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();    
    ++c1;//使用重载运算符++完成复数前置++  
    cout<<"after ++c1,c1=";  
    c1.Show();  
    c2++;   //使用重载运算符++完成复数后置++  
    cout<<"after c2++,c2=";  
    c2.Show();    
    return 0;  
}

9.6 复数类对象的++运算-重载++运算符为友元函数

用++运算符实现复数对象的实部加1，用重载++为友元函数。

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
    complex(double r=0.0,double i=0.0){real=r;imag=i;}  
      
    friend complex operator ++(complex &c);  
    friend complex operator ++(complex &c,int);   
  
    void Show();      
private:      
    double real;      
    double imag;      
};    
  
complex operator ++(complex &c)    
{   complex t;  
    t.real=c.real+1;  
    t.imag=c.imag;  
    c.real=c.real+1;  
    c.imag=c.imag;  
    return t;  
}  
  
complex operator ++(complex &c,int)  
{   complex t;  
    t.real=c.real;  
    t.imag=c.imag;  
    c.real=c.real+1;  
    c.imag=c.imag;  
    return t;  
}  
  
  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  


int main()     //主函数  
{  
    double a,b,c,d;  
    cin>>a>>b>>c>>d;  
    complex c1(a,b),c2(c,d);  //声明复数类的对象,c1,c2有参  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();    
    ++c1;//使用重载运算符++完成复数前置++  
    cout<<"after ++c1,c1=";  
    c1.Show();  
    c2++;   //使用重载运算符++完成复数后置++  
    cout<<"after c2++,c2=";  
    c2.Show();    
    return 0;  
}

9.7 日期类设计与运算符重载

在Date类中，重载++运算符（前置、后置）为成员函数，使得在当前日期上加上1天形成一个新的日期。

#include <iostream>     
using namespace std;  
class Date  
{  
private:  
    int yr,mn,dy;  
  
public:  
    void ShowMe()  
    {  
        cout<<yr<<"-"<<mn<<"-"<<dy<<endl;  
    }  
    Date operator ++();   
    Date operator ++(int);   
  
    Date(int a=0,int b=0,int c=0)  
    {  
        yr=a; mn=b; dy=c;  
    }  
  
};  
  
Date Date::operator ++()  
{  
      
    if(mn==2)     
        {     
            if(dy>=28)     
            {     
                dy=1;     
                mn+=1;     
            }     
        }     
        else if(mn==1||mn==3||mn==5||mn==7||mn==8||mn==10)     
        {     
            if(dy<31)     
            {     
                dy+=1;     
            }     
            else    
            {     
                dy=1;     
                mn+=1;     
            }     
        }     
        else if(mn==12)     
        {     
            if(dy<31)     
            {     
                dy+=1;     
            }     
            else    
            {     
                dy=1;     
                mn=1;     
                yr+=1;     
            }     
        }     
        else    
        {     
            if(dy<30)     
            {     
                dy+=1;     
            }     
            else    
            {     
                dy=1;     
                mn+=1;     
            }     
        }   
        Date d;    
  
  
    d.yr=yr;  
    d.mn=mn;  
    d.dy=dy;  
    yr=yr;  
    mn=mn;  
    dy=dy;  
    return d;  
}  
Date Date::operator ++(int)  
{  
    if(mn==2)     
        {     
            if(dy>=28)     
            {     
                dy=1;     
                mn+=1;     
            }     
        }     
        else if(mn==1||mn==3||mn==5||mn==7||mn==8||mn==10)     
        {     
            if(dy<31)     
            {     
                dy+=1;     
            }     
            else    
            {     
                dy=1;     
                mn+=1;     
            }     
        }     
        else if(mn==12)     
        {     
            if(dy<31)     
            {     
                dy+=1;     
            }     
            else    
            {     
                dy=1;     
                mn=1;     
                yr+=1;     
            }     
        }     
        else    
        {     
            if(dy<30)     
            {     
                dy+=1;     
            }     
            else    
            {     
                dy=1;     
                mn+=1;     
            }     
        }   
    Date d;  
      
    d.yr=yr;  
    d.mn=mn;  
    d.dy=dy;  
    yr=yr;  
    mn=mn;  
    dy=dy;  
    return d;  
}  

int main()  
{  
   int a,b,c;  
   cin>>a>>b>>c;//从键盘输入年月日  
   Date x(a,b,c);//定义一个日期对象，带参数  
   x.ShowMe();//输出年月日  
   x++;//把当前日期改为第二天  
   x.ShowMe();//输出第二天的年月日     
   ++x;//把当前日期改为第二天  
   x.ShowMe();//输出第二天的年月日     
   return 0;  
}

9.8 复数的加法运算–成员函数重载

实现复数的加法运算，要求通过成员函数重载的方法实现2个复数对象的加运算、1个复数与1个实数的加运算。

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
    complex(double r=0.0,double i=0.0){real=r;imag=i;}  
      
    complex add(complex &c2);   
    complex add(double e);  
    void Show();      
private:      
    double real;      
    double imag;      
};    
  
complex complex::add(complex &c2)    
{   complex t;  
    t.real=real+c2.real;  
    t.imag=imag+c2.imag;  
    return t;  
}  
complex complex::add(double e)  
{  
    complex t;  
    t.real=real+e;  
    t.imag=imag;  
    return t;  
}  
  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  


int main()     //主函数  
{  
    double a,b,c,d,e;  
    cin>>a>>b>>c>>d>>e;  
    complex c1(a,b),c2(c,d),c3;  //声明复数类的对象  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();  
    c3=c1.add(c2);  //使用成员函数add完成c1和c2对象完成复数加法  
    cout<<"c3=c1+c2=";  
    c3.Show();  
    c3=c1.add(e);//使用成员函数add完成c1对象和实数e完成复数加法  
    cout<<"c3=c1+e=";  
    c3.Show();  
    return 0;  
}

9.9 复数的加法运算-友元函数重载

实现复数的加法运算，要求通过友元函数重载的方法实现2个复数对象的加运算、1个复数与1个实数的加运算。

#include <iostream>     
using namespace std;  
class complex     
{  
public:   
    complex(double r=0.0,double i=0.0){real=r;imag=i;}  
      
    friend complex add(complex &c1,complex &c2);   
    friend complex add(complex &c1,double e);  
    void Show();      
private:      
    double real;      
    double imag;      
};    
  
complex add(complex &c1,complex &c2)    
{   complex t;  
    t.real=c1.real+c2.real;  
    t.imag=c1.imag+c2.imag;  
    return t;  
}  
complex add(complex &c1,double e)  
{  
    complex t;  
    t.real=c1.real+e;  
    t.imag=c1.imag;  
    return t;  
}  
  
void complex::Show()  
{   cout<<"("<<real<<","<<imag<<")"<<endl;   
}  


int main()     //主函数  
{  
    double a,b,c,d,e;  
    cin>>a>>b>>c>>d>>e;  
    complex c1(a,b),c2(c,d),c3;  //声明复数类的对象  
    cout<<"c1=";  
    c1.Show();  
    cout<<"c2=";  
    c2.Show();  
    c3=add(c1,c2);  //使用友元函数add完成c1和c2对象完成复数加法  
    cout<<"c3=c1+c2=";  
    c3.Show();  
    c3=add(c1,e);//使用友元函数add完成c1对象和实数e完成复数加法  
    cout<<"c3=c1+e=";  
    c3.Show();  
    return 0;  
}
帕蒂与史密斯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6-4 复数的加减运算 (30 分)
aa12aaaaaa的博客
04-07 4768
6-4 复数的加减运算 (30 分) ###复数加减（友元的应用） 声明一个复数类CComplex（类私有数据成员为double型的real和image） 定义构造函数，用于指定复数的实部与虚部。 定义成员函数，调用该函数时，以格式real+image i的格式输出当前对象（当虚部为正数时，实部虚部中间用+号连接，当虚部为复数时，实部虚部用-号连接）。 编写加法友元函数，以复数对象c1, c2为参数，求两个复数对象之和（实部虚部分别相加）。 编写减法友元函数，以复数对象c1, c2为参数，求两个复数对象的差
C++编程学习笔记 week7
巴别塔
01-16 167
构造函数与析构函数 6.1 日期类用法–几种构造函数定义 定义一个日期类，该类数据成员有年、月、日3个私有数据。公有成员函数按指定格式输出日期，构造函数有4个：无参构造函数、带普通参数的构造函数、带字符串参数的构造函数、自定义拷贝构造函数。在主函数中通过构造函数进行对象初始化，以年-月-日格式输出日期。要求在类中补充4个构造函数定义。 #include &amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; #incl...
运算符重载为类的成员函数实现复数的加减乘等运算(c++)
ttttt1_的博客
06-14 618
//实现复数的加减乘等运算(运算符重载为类的成员函数) #include <iostream> using namespace std; class Com { private: int a, b; public: Com(int i=0, int j=0) :a(i), b(j) {}; Com operator+(Com &p); Com operator-(Com &p); Com operator*(Com &p); Com&a...
C++基础编程题（30）通过函数来实现复数相加
weixin_43774841的博客
02-02 777
使用运算符重载实现复数的加法运算
热门推荐
meishadevs的个人博客
06-10 1万+
在使用运算符
c++派生（编程实现Complex复数类的加法运算。）
Kerryliuyue的博客
05-09 1733
编程实现Complex复数类的加法运算。 方法一 #include <iostream> using namespace std; class complex { public: complex() { real=0,imag=0; } complex( float re,float im) { real=re; imag=im; } complex Add(const complex &a
c++基础全套学习笔记（入门）
lzq00277的博客
10-03 4168
C++入门
c++快速入门学习笔记（详细到泪目）
weixin_46020788的博客
03-23 980
本笔记只是记录一些比较简单的随堂随笔，部分内容涉及基础知识的，将会在其他篇文章进行论述。本笔记随时间推移与知识积累不断更新。 C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。 C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。 初步了解–通过输出“Hello World”来看看。 #include <ios...
C#高级编程-学习笔记.pdf
03-12
通过以上分析可知，C#高级编程学习笔记中所包含的知识点对于深入理解这门语言至关重要。枚举的使用可以让代码更清晰、易于维护；类和结构的选择基于性能和需求；常量和事件可以增强代码的可读性和交互能力；而函数...
c++整理笔记.docx
03-08
根据提供的文档内容，我们可以总结出以下几个关键知识点： ### 1. C++ 变量初始化 在 C++ 中，为了确保程序的稳定性和可预测性，当声明一个变量时，建议立即给它赋...掌握这些基本概念对于学习和使用 C++ 至关重要。
6.9 复数类对象的加法运算-成员函数
虾编的小本本
11-09 1506
#要求定义成员函数实现2个复数对象的加法运算。 提示：复数的加法按照以下规定的法则进行：设z1=a+bi,z2=c+di是任意两个复数，则它们的和z3是 (a+bi)+(c+di)=(a+c)+(b+d)i. 解题思路： 在类当中除了能够包含数据项int double char等类型，当然还能包括函数 函数当中不但能引入固有的数据类型，还能引入自身的类，在此题中就有体现 后置代码： int mai...
以复数运算为实例的类实现、函数重载、模板类操作
SoyBean
12-09 626
首选，我们利用类来实现复数的加法，这不是我们讨论的重点，代码直接给出： #include using namespace std; class complexx { public: complexx(int j=0 ,int k=0)//构造函数 { x=j; y=k; } complexx add(complexx &b)//相
6.8 复数类对象的加法运算-友元函数
虾编的小本本
11-09 1545
要求定义友元函数实现2个复数对象的加法运算。 提示：复数的加法按照以下规定的法则进行：设z1=a+bi,z2=c+di是任意两个复数，则它们的和z3是 (a+bi)+(c+di)=(a+c)+(b+d)i. 解题思路 ：这里用到了友元函数注意结合6.9 去看 分析友元函数和成员函数的区别。 #include &lt;iostream&gt; using namespace std; class ...
秒达开源多功能中文工具箱源码：自部署 全开源 轻量级跨平台 GPT级支持+高效UI+Docker
最新发布
09-09
【秒达开源】多功能中文工具箱源码发布：自部署、全开源、轻量级跨平台，GPT级支持+高效UI，Docker/便携版任选，桌面友好+丰富插件生态 这是一款集大成之作，专为追求高效与便捷的用户量身打造。它不仅支持完全自部署，还实现了彻底的开源，确保每一位开发者都能深入了解其内核，自由定制与扩展。 【秒达开源工具箱】以其轻量级的架构设计，实现了在各类设备上的流畅运行，包括ARMv8架构在内的全平台支持，让您无论身处何地，都能享受到同样的便捷体验。我们深知用户需求的多样性，因此特别引入了类似GPT的智能支持功能，让您的操作更加智能、高效。 与此同时，我们注重用户体验，将高效UI与工具箱功能高度集成，使得界面简洁直观，操作流畅自然。为了满足不同用户的部署需求，我们还提供了Docker映像和便携式版本，让您可以根据实际情况灵活选择。 值得一提的是，我们的工具箱还支持桌面版应用，让您在PC端也能享受到同样的强大功能。此外，我们还建立了丰富的开源插件库，不断扩展工具箱的功能边界，让您的工具箱永远保持最新、最全。 【秒达开源】多功能中文工具箱，作为一款永远的自由软件，我们承诺将持续更新、优化，为
双极 AMI 的加扰以及 B8ZS 和 HDB3 加扰simulink.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
C项目开发资源.docx
09-09
对于C/C++项目开发，有许多资源和工具可以帮助开发者提高效率、保证代码质量以及实现项目的自动化构建和部署。以下是一些具体的资源和工具： 1. **集成开发环境(IDE)**: - **CLion**: 专为C和C++开发设计的跨平台IDE，提供了代码分析、调试、版本控制集成等功能。 - **Eclipse CDT**: 基于Eclipse的C/C++开发工具，支持代码补全、调试和项目管理。 - **Visual Studio**: Windows平台上功能强大的IDE，提供了丰富的C++开发支持。 - **Code::Blocks**: 开源的C/C++ IDE，体积小且可定制。 - **KDevelop**: 另一个功能丰富的开源IDE，主要针对Linux平台。 2. **代码编辑器**: - **Visual Studio Code**: 通过C/C++扩展插件，如C/C++插件包，提供智能感知、代码调试等功能。 - **Sublime Text**: 轻量级的文本编辑器，支持大量插件，包括C/C++编译和语法高亮。 3. **编译
基于ssm的在线购物系统的设计与实现设计与实现.docx
09-09
基于ssm的在线购物系统的设计与实现设计与实现.docx
python-对Excel数据处理做可视化分析.zip
09-09
灵敏度分析
C++学习笔记：编程理解与入门指南
"C++学习笔记，涵盖从基础到高级的主题，旨在帮助初学者理解编程概念，而不仅仅是学习C++语言的语法。笔记作者强调基础的重要性，并以个人理解和实践经验为基础进行阐述，可能会与传统教材有所不同。" C++学习笔记...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值