2023.10.10

news2024/11/16 21:37:51

运算符重载

类外函数实现：

#include <iostream>

using namespace std;

class Good
{
    //算数
    friend const Good operator*(const Good &L,const Good &R);
    friend const Good operator+(const Good &L,const Good &R);
    friend const Good operator/(const Good &L,const Good &R);
    friend const Good operator-(const Good &L,const Good &R);
    friend const Good operator%(const Good &L,const Good &R);
    //关系
    friend bool operator>(const Good &L,const Good &R);
    friend bool operator>=(const Good &L,const Good &R);
    friend bool operator<(const Good &L,const Good &R);
    friend bool operator<=(const Good &L,const Good &R);
    friend bool operator==(const Good &L,const Good &R);
    //赋值
    friend Good &operator-=(Good &L,const Good &R);
    friend Good &operator+=(Good &L,const Good &R);
    friend Good &operator*=(Good &L,const Good &R);
    friend Good &operator/=(Good &L,const Good &R);
    friend Good &operator%=(Good &L,const Good &R);
private:
    int n;
    int f;
    int a;
public:
    Good(){}
    Good(int n,int f,int a):n(n),f(f),a(a){}
    void show() const
    {
        cout << "n:" << n << endl;
        cout << "f:" << f << endl;
        cout << "a:" << a << endl;
        //cout << "常" << endl;
    }

};
//非成员
//算数+
const Good operator+(const Good &L,const Good &R)
{
    Good t;
    t.a=L.a+R.a;
    t.n=L.n+R.n;
    t.f=L.f+R.f;
    return t;
}
//算数*
const Good operator*(const Good &L,const Good &R)
{
    Good t;
    t.a=L.a*R.a;
    t.n=L.n*R.n;
    t.f=L.f*R.f;
    return t;
}
//算数-
const Good operator-(const Good &L,const Good &R)
{
    Good t;
    t.a=L.a-R.a;
    t.n=L.n-R.n;
    t.f=L.f-R.f;
    return t;
}
//算数/
const Good operator/(const Good &L,const Good &R)
{
    Good t;
    t.a=L.a/R.a;
    t.n=L.n/R.n;
    t.f=L.f/R.f;
    return t;
}
//算数%
const Good operator%(const Good &L,const Good &R)
{
    Good t;
    t.a=L.a%R.a;
    t.n=L.n%R.n;
    t.f=L.f%R.f;
    return t;
}
//关系运算<
bool operator<(const Good &L,const Good &R)
{
    if(L.a<R.a && L.n<R.n && L.f<R.f){
        return true;
    }else{
        return false;
    }
}
//关系运算>
bool operator>(const Good &L,const Good &R)
{
    if(L.a>R.a && L.n>R.n && L.f>R.f){
        return true;
    }else{
        return false;
    }
}
//关系运算>=
bool operator>=(const Good &L,const Good &R)
{
    if(L.a>=R.a && L.n>=R.n && L.f>=R.f){
        return true;
    }else{
        return false;
    }
}
//关系运算<=
bool operator<=(const Good &L,const Good &R)
{
    if(L.a<=R.a && L.n<=R.n && L.f<=R.f){
        return true;
    }else{
        return false;
    }
}
//关系运算==
bool operator==(const Good &L,const Good &R)
{
    if(L.a==R.a && L.n==R.n && L.f==R.f){
        return true;
    }else{
        return false;
    }
}
//赋值运算-=
Good &operator-=(Good &L,const Good &R)
{
    L.a-=R.a;
    L.n-=R.n;
    L.f-=R.f;
    return L;
}
//赋值运算+=
Good &operator+=(Good &L,const Good &R)
{
    L.a+=R.a;
    L.n+=R.n;
    L.f+=R.f;
    return L;
}
//赋值运算*=
Good &operator*=(Good &L,const Good &R)
{
    L.a*=R.a;
    L.n*=R.n;
    L.f*=R.f;
    return L;
}
//赋值运算/=
Good &operator/=(Good &L,const Good &R)
{
    L.a/=R.a;
    L.n/=R.n;
    L.f/=R.f;
    return L;
}
//赋值运算%=
Good &operator%=(Good &L,const Good &R)
{
    L.a%=R.a;
    L.n%=R.n;
    L.f%=R.f;
    return L;
}

int main()
{
    cout << "-----0-----" << endl;
    Good s0(1,2,3);
    s0.show();
    cout << "-----1-----" << endl;
    Good s1(3,2,1);
    s1.show();
    cout << "----2.0----" << endl;
    Good s2=s0+s1;
    s2.show();
    cout << "----2.1----" << endl;
    s2+=s1;
    s2.show();
    cout << "s2>s1?" << endl;
    bool outcome=s2>s1;
    cout << outcome << endl;
    return 0;
}

类内函数实现：

#include <iostream>

using namespace std;

class Good
{
private:
    int n;
    int f;
    int a;
public:
    Good(){}
    Good(int n,int f,int a):n(n),f(f),a(a){}
    void show() const
    {
        cout << "n:" << n << endl;
        cout << "f:" << f << endl;
        cout << "a:" << a << endl;
    }
    //成员
    //算数+
    const Good operator+(const Good &p) const
    {
        Good t;
        t.a=a+p.a;
        t.n=n+p.n;
        t.f=f+p.f;
        return t;
    }
    //算数-
    const Good operator-(const Good &p) const
    {
        Good t;
        t.a=a-p.a;
        t.n=n-p.n;
        t.f=f-p.f;
        return t;
    }
    //算数*
    const Good operator*(const Good &p) const
    {
        Good t;
        t.a=a*p.a;
        t.n=n*p.n;
        t.f=f*p.f;
        return t;
    }
    //算数/
    const Good operator/(const Good &p) const
    {
        Good t;
        t.a=a/p.a;
        t.n=n/p.n;
        t.f=f/p.f;
        return t;
    }
    //算数%
    const Good operator%(const Good &p) const
    {
        Good t;
        t.a=a%p.a;
        t.n=n%p.n;
        t.f=f%p.f;
        return t;
    }
    //关系>
    bool operator>(const Good &R) const
    {
        if(a>R.a && n>R.n && f>R.f){
            return true;
        }else{
            return false;
        }
    }
    //关系<
    bool operator<(const Good &R) const
    {
        if(a<R.a && n<R.n && f<R.f){
            return true;
        }else{
            return false;
        }
    }
    //关系==
    bool operator==(const Good &R) const
    {
        if(a==R.a && n==R.n && f==R.f){
            return true;
        }else{
            return false;
        }
    }
    //关系>=
    bool operator>=(const Good &R) const
    {
        if(a>=R.a && n>=R.n && f>=R.f){
            return true;
        }else{
            return false;
        }
    }
    //关系<=
    bool operator<=(const Good &R) const
    {
        if(a<=R.a && n<=R.n && f<=R.f){
            return true;
        }else{
            return false;
        }
    }
    //赋值+=
    Good &operator+=(const Good &R)
    {
        a+=R.a;
        n+=R.n;
        f+=R.f;
        return *this;
    }
    //赋值=
    Good &operator=(const Good &R)
    {
        a=R.a;
        n=R.n;
        f=R.f;
        return *this;
    }
    //赋值-=
    Good &operator-=(const Good &R)
    {
        a-=R.a;
        n-=R.n;
        f-=R.f;
        return *this;
    }
    //赋值%=
    Good &operator%=(const Good &R)
    {
        a%=R.a;
        n%=R.n;
        f%=R.f;
        return *this;
    }
    //赋值/=
    Good &operator/=(const Good &R)
    {
        a/=R.a;
        n/=R.n;
        f/=R.f;
        return *this;
    }
    //赋值*=
    Good &operator*=(const Good &R)
    {
        a*=R.a;
        n*=R.n;
        f*=R.f;
        return *this;
    }
};

int main()
{
    cout << "-----0-----" << endl;
    Good s0(1,2,3);
    s0.show();
    cout << "-----1-----" << endl;
    Good s1(3,2,1);
    s1.show();
    cout << "----2.0----" << endl;
    Good s2=s0+s1;
    s2.show();
    cout << "----2.1----" << endl;
    s2+=s1;
    s2.show();
    cout << "s2>s1?" << endl;
    bool outcome=s2>s1;
    cout << outcome << endl;
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1077170.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【网络豆送书第五期】Kali Linux高级渗透测试

【网络豆送书第五期】Kali Linux高级渗透测试

作者简介&#xff1a;一名云计算网络运维人员、每天分享网络与运维的技术与干货。 公众号&#xff1a;网络豆云计算学堂 座右铭&#xff1a;低头赶路&#xff0c;敬事如仪 个人主页&#xff1a; 网络豆的主页​​​​​ 本期好书推荐&#xff1a;《Kali Linux高级渗透测试…
阅读更多...
在Openresty中使用lua语言向请求浏览器返回请求头User-Agent里边的值

在Openresty中使用lua语言向请求浏览器返回请求头User-Agent里边的值

可以参考《Linux学习之Ubuntu 20.04在https://openresty.org下载源码安装Openresty 1.19.3.1&#xff0c;使用systemd管理OpenResty服务》安装Openresty。 然后把下边的内容写入到openresty配置文件/usr/local/openresty/nginx/conf/nginx.conf&#xff08;根据实际情况进行选…
阅读更多...
vue使用localstorage超出限制解决方法

vue使用localstorage超出限制解决方法

最近在项目中&#xff0c;遇到一个报错&#xff0c;QuotaExceededError: The quota has been exceeded。如图&#xff1a; 搜索了一下&#xff0c;结合项目代码&#xff0c;得到的结论是localStorage超出5M限制了&#xff0c;项目中使用了vuex-persistedstate插件&#xff0c;…
阅读更多...
机器学习、深度学习相关的项目集合【自行选择即可】

机器学习、深度学习相关的项目集合【自行选择即可】

【基于YOLOv5的瓷砖瑕疵检测系统】 YOLOv5是一种目标检测算法&#xff0c;它是YOLO&#xff08;You Only Look Once&#xff09;系列模型的进化版本。YOLOv5是由Ultralytics开发的&#xff0c;基于一阶段目标检测的概念。其目标是在保持高准确率的同时提高目标检测的速度和效率…
阅读更多...
win11安装IIS步骤-已验证23.10.10

win11安装IIS步骤-已验证23.10.10

IIS服务使用 步骤一&#xff1a;打开控制面板 通过 控制面板— 程序— 启用或关闭Windows功能 — 选择Internet Information Services默认安装IIS&#xff0c;如下图步骤所示 步骤二&#xff1a;打开IIS服务 建议根据下图勾选&#xff0c;建议全选安装&#xff0c;以便后续发…
阅读更多...
计算机算法分析与设计（9）---0-1背包问题(含C++代码)

计算机算法分析与设计（9）---0-1背包问题(含C++代码)

文章目录 一、概述1.1 问题描述1.2 算法思想 二、代码2.1 题目描述2.2 代码编写 一、概述 1.1 问题描述 1. 0-1背包问题&#xff1a;给定 n n n 种物品和一背包。物品 i i i 的体积是 v i v_i vi​&#xff0c;其价值为 w i w_i wi​&#xff0c;背包的容量为 c c c。问应…
阅读更多...
winform窗体控件太多显示不过来，怎么实现滚动条

winform窗体控件太多显示不过来，怎么实现滚动条

winform窗体控件太多显示不过来&#xff0c;怎么实现滚动条 Winform Panel实现滚动条 一、创建panel 在界面上拖拽一个父级Panel1&#xff0c;然后在Panel1里面拖拽一个子级Panel2 设置父级Panel1的AutoScroll属性为True 属性设置好后&#xff0c;当子级高度或者宽度大于父…
阅读更多...
promtail multiline 堆栈日志处理

promtail multiline 堆栈日志处理

找到自己的promtail.yaml中job_name段落&#xff0c;增加multiline段落&#xff0c;下面文件只是部分内容&#xff0c;只需要修改firstline后面的正则表达式匹配日志行首&#xff0c;如果堆栈换行后不是此格式行首&#xff0c;将自动把堆栈的行合并到上一行中。 - job_name: k…
阅读更多...
【管理运筹学】第 9 章 | 网络计划（2，时间参数的计算 —— 工作时间的确定与事项的时间参数）

【管理运筹学】第 9 章 | 网络计划（2，时间参数的计算 —— 工作时间的确定与事项的时间参数）

文章目录 引言一、工作时间的确定二、事项的时间参数2.1 事项的最早开始时间2.2 事项的最迟结束时间2.3 事项的时差2.4 利用事项的时间参数来确定关键线路 引言 计算网络图中有关的时间参数&#xff0c;主要目的是找到关键线路&#xff0c;为网络计划的优化、调增和执行提供明…
阅读更多...
LabVIEW玩转魔方

LabVIEW玩转魔方

LabVIEW玩转魔方 使用LabVIEW创建一个3D魔方&#xff0c;并找出解谜题的秘密&#xff0c;给朋友留下深刻深刻的印象。游戏中内置的机制使每张脸都能独立转动&#xff0c;从而混合颜色。要解决难题&#xff0c;每个面必须是相同的纯色 魔方的奥秘在于它的简单性和不可解性。这是…
阅读更多...
点餐小程序实战教程08-购物车功能开发

点餐小程序实战教程08-购物车功能开发

目录 1 创建购物车2 增加数量3 减少数量4 切换分类时回填数据5 显示购物车信息总结 我们上一篇搭建了点餐业务的数据初始化加载&#xff0c;本篇实现一下加入购物车的功能。在购物车设计的时候有两种方案&#xff0c;一种是使用数据表的方案&#xff0c;一种是使用变量的方案。…
阅读更多...
手机拍摄的视频噪点很多怎么办，视频怎么做降噪处理？

手机拍摄的视频噪点很多怎么办，视频怎么做降噪处理？

现如今&#xff0c;智能手机已经成为了我们生活中必不可少的存在。而随着智能手机越来越强大&#xff0c;很多人已经开始使用手机来拍摄各种类型的视频。但是由于手机的限制&#xff0c;很多人会发现自己拍摄的视频存在着很多的噪点。那么&#xff0c;我们该怎样来解决拍摄视频…
阅读更多...
深入理解强化学习——强化学习和有监督学习

深入理解强化学习——强化学习和有监督学习

分类目录&#xff1a;《深入理解强化学习》总目录 通过前文的介绍&#xff0c;我们现在应该已经对强化学习的基本数学概念有了一定的了解。这里我们回过头来再看看一般的有监督学习和强化学习的区别。以图片分类为例&#xff0c;有监督学习&#xff08;Supervised Learning&…
阅读更多...
idea软件_启动出错永久办法leetcode关联

idea软件_启动出错永久办法leetcode关联

目录 idea启动出错启动出错原因1 永久关联leetcode idea启动出错 idea启动没反应的话&#xff0c;在idea的安装目录bin目录下有idea.bat&#xff0c;加入pause&#xff0c;双击启动&#xff0c;如果有问题,idea不会启动&#xff0c;控制台会输出相应错误信息&#xff0c;如果没…
阅读更多...
互联网Java工程师面试题·Java 并发编程篇·第二弹

互联网Java工程师面试题·Java 并发编程篇·第二弹

目录 14、什么是 Callable 和 Future? 15、什么是 FutureTask?使用 ExecutorService 启动任务。 16、什么是并发容器的实现&#xff1f; 17、多线程同步和互斥有几种实现方法&#xff0c;都是什么&#xff1f; 18、什么是竞争条件&#xff1f;你怎样发现和解决竞争&…
阅读更多...
Jetson Orin NX 开发指南（1）: 系统烧录

Jetson Orin NX 开发指南（1）: 系统烧录

一、SDK Manager SDK Manager 工具是 NVIDIA 官方推荐的烧写和管理 Jetpack 系统组件的一个图形化烧写工具&#xff0c;使用起来非常的简单方便&#xff0c;但是该软件需要在 x86 的 Ubuntu 18.04 或 Ubuntu 20.04 的系统上运行&#xff0c;因此我们需要准备一台安装了 Ubuntu…
阅读更多...
照片怎么压缩变小？

照片怎么压缩变小？

照片怎么压缩变小&#xff1f;在使用聊天工具时&#xff0c;出现无法传输照片的情况很常见&#xff0c;这通常是因为电脑或手机中照片的文件体积太大了。此外&#xff0c;如果照片过大&#xff0c;也会占用设备的内存&#xff0c;导致设备性能下降。因此&#xff0c;我们需要将…
阅读更多...
广告牌安全监测，保障户外广告牌的安全与稳定

广告牌安全监测，保障户外广告牌的安全与稳定

随着城市的发展和现代化&#xff0c;广告牌已经成为城市风景的一部分。然而&#xff0c;随之而来的是广告牌安全问题&#xff0c;因为它们暴露在各种天气和环境条件下&#xff0c;一旦掉落&#xff0c;可能对人们的生命和财产造成威胁。广告牌安全监测有效的解决了这一问题&…
阅读更多...
腾讯云2核4G轻量服务器5M带宽支持多少人同时在线？

腾讯云2核4G轻量服务器5M带宽支持多少人同时在线？

腾讯云轻量2核4G5M带宽服务器支持多少人在线访问&#xff1f;5M带宽下载速度峰值可达640KB/秒&#xff0c;阿腾云以搭建网站为例&#xff0c;假设优化后平均大小为60KB&#xff0c;则5M带宽可支撑10个用户同时在1秒内打开网站&#xff0c;从CPU内存的角度&#xff0c;网站程序效…
阅读更多...
Python中协程异步IO（asyncio）理解与入门

Python中协程异步IO（asyncio）理解与入门

1、asyncio import asyncio# coroutine function: async开头的函数 async def main():print(hello)await asyncio.sleep(1)print(world)coro main() # coroutine object&#xff1a;协程对象# 当生成协程对象的时候&#xff0c;并不运行函数里面的程序。 # 运行时需要两步走…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023