C++

已于 2024-09-03 18:17:36 修改
阅读量794 收藏 8
点赞数 2
文章标签： c++ 开发语言
于 2024-09-03 18:14:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57106106/article/details/141868501
版权

关系运算符重载

种类：>，<，==，<=，>=

表达式：左操作数 运算符 右操作数

左操作数：可以是左值，也可以是右值，运算过程中不能被改变。

右操作数：可以是左值，也可以是右值，运算过程中不能被改变。

结果：bool

成员函数实现算数运算符重载

bool operator 运算符（const 类名 &右操作数） const

全局函数实现算数运算符重载

bool operator 运算符（const 类名 &左操作数，const 类名 &右操作数）

#include <iostream>

using namespace std;

//封装类
class Stu
{
    friend bool operator>(const Stu &left,const Stu &right);
private:
    int a;
    int b;
public:
    Stu()
    {

    }

    Stu(int a,int b):a(a),b(b)
    {

    }

    void show()
    {
        cout << "a= " << a << endl;
        cout << "b= " << b << endl;
    }
/*
    //成员函数实现关系运算符重载
    bool operator>(const Stu &right) const
    {
        if(a > right.a && b > right.b)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
*/
};

//全局函数实现关系运算符重载
bool operator>(const Stu &left,const Stu &right)
{
    if(left.a > right.a && left.b > right.b)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int main()
{
    Stu s1(2,3);
    Stu s2(4,5);
    if(s1 > s2)
    {
        cout << "s1>s2" <<endl;
    }
    else
    {
        cout << "s1<s2" <<endl;
    }

    return 0;
}

赋值运算符重载

种类：=，+=，-=，*=，/=

表达式：左操作数 运算符 右操作数

左操作数：只能是左值，运算过程中需要被改变。

右操作数：可以是左值，也可以是右值，运算过程中不能被改变。

结果：自身的引用

成员函数实现算数运算符重载

类名 &operator 运算符（const 类名 &right）

{}

全局函数实现算数运算符重载

类名 &operator 运算符（类名 &light，const 类名 &right）

{}

#include <iostream>

using namespace std;

//封装类
class Stu
{
    friend Stu operator+=(Stu &left,const Stu &right);
private:
    int a;
    int b;
public:
    Stu()
    {

    }

    Stu(int a,int b):a(a),b(b)
    {

    }

    void show()
    {
        cout << "a= " << a << endl;
        cout << "b= " << b << endl;
    }
/*
    //成员函数实现赋值运算符重载
    Stu operator+=(const Stu &right)
    {
       a += right.a;
       b += right.b;
       return *this;
    }
*/
};

//全局函数实现赋值运算符重载
Stu operator+=(Stu &left,const Stu &right)
{
    left.a += right.a;
    left.b += right.b;
    return left;
}

int main()
{
    Stu s1(2,3);
    Stu s2(4,5);
    Stu s3(1,1);
    s3 += s2 += s1;
    s3.show();
    return 0;
}

自增自减运算符重载

种类：++，--

表达式：左操作数 运算符 右操作数

左操作数：只能是左值，运算过程中需要被改变。

右操作数：可以是左值，也可以是右值，运算过程中不能被改变。

结果：自身的引用

成员函数实现前置自增运算符重载

类名 operator ++（）

{}

全局函数实现前置自增运算符重载

类名 operator ++（类名 &self）

{}

#include <iostream>

using namespace std;

//封装类
class Stu
{
    friend Stu operator++(Stu &self);
private:
    int a;
    int b;
public:
    Stu()
    {

    }

    Stu(int a,int b):a(a),b(b)
    {

    }

    void show()
    {
        cout << "a= " << a << endl;
        cout << "b= " << b << endl;
    }
/*
    //成员函数实现前置自增运算符重载
    Stu operator++()
    {
       ++a;
       ++b;
       return *this;
    }
*/
};

//全局函数实现前置自增运算符重载
Stu operator++(Stu &self)
{
    ++self.a;
    ++self.b;
    return self;
}

int main()
{
    Stu s1(2,3);
    Stu s2(4,5);
    ++s1;
    s1.show();
    return 0;
}

表达式：左操作数 运算符

左操作数：只能是左值，运算过程中需要被改变。

结果：只能是右值（不能改变）

成员函数实现后置自增运算符重载

const 类名 operator ++（int）

{}

全局函数实现后置自增运算符重载

const 类名 operator ++（类名 &self，int）

{}

#include <iostream>

using namespace std;

//封装类
class Stu
{
    friend Stu operator++(Stu &self,int);
private:
    int a;
    int b;
public:
    Stu()
    {

    }

    Stu(int a,int b):a(a),b(b)
    {

    }

    void show()
    {
        cout << "a= " << a << endl;
        cout << "b= " << b << endl;
    }
/*
    //成员函数实现后置自增运算符重载
    Stu operator++(int)
    {
    Stu temp;
    temp.a = a++;
    temp.b = b++;
    return temp;
    }
*/
};

//全局函数实现后置自增运算符重载
Stu operator++(Stu &self,int)
{
    Stu temp;
    temp.a = self.a++;
    temp.b = self.b++;
    return temp;
}

int main()
{
    Stu s1(2,3);
    Stu s2(4,5);
    Stu s3;
    s3 = s1++;
    s1.show();
    s3.show();
    return 0;
}

插入，提取运算符重载

插入符：<<

提取符：>>

表达式：左操作数 运算符 右操作数

左操作数：只能是左值，运算过程中需要被改变。

右操作数：可以是左值，也可以是右值，运算过程中不能被改变。

结果：自身的引用

全局函数实现算数运算符重载

ostream &operator<<(const ostream &cout,const Stu &s)

{}

#include <iostream>

using namespace std;

//封装类
class Stu
{
    friend ostream &operator<<(ostream &cout,const Stu &s);
    friend istream &operator>>(istream &cin,Stu &s);
private:
    int a;
    int b;
public:
    Stu()
    {

    }

    Stu(int a,int b):a(a),b(b)
    {

    }

    void show()
    {
        cout << "a= " << a << endl;
        cout << "b= " << b << endl;
    }
};

//全局函数实现提取，插入运算符重载
ostream &operator<<(ostream &cout,const Stu &s)
{
    cout << s.a << s.b <<endl;
    return cout;
}

istream &operator>>(istream &cin,Stu &s)
{
    cin >> s.a >> s.b;
    return cin;
}

int main()
{
    Stu s1(2,3);
    Stu s2(4,5);
    Stu s3;
    cin >> s1 >> s2;
    cout << s2 << s1 << endl;
    return 0;
}

不能重载的运算符

  1. 访问内部成员
  2. 指针访问内部成员（->）
  3. 三目运算符
  4. 作用域限定符（：：）
  5. sizeof（）

静态成员

静态数据成员和静态成员函数属于类，不属于类的某个实例（某个对象），它们在所有实例中都是共享的。

在数据成员前加上static ---> 静态数据成员

在成员函数前加上staric ---> 静态成员函数

静态数据成员必须在类外初始化，如果不初始化，默认为0（不建议）

静态成员函数只能访问静态数据成员，不能访问非静态数据成员

格式：

class  类名
{
    static 数据类型 变量名; //静态数据成员
    
    static 返回值类型 函数名(形参列表) //静态成员函数
    {}
};

例：

#include <iostream>

using namespace std;

//封装类
class Bank
{
private:
    double money;
    static double rate;  //静态数据成员
public:
    Bank()
    {

    }
    Bank(double m):money(m)
    {

    }
    static double getRate()  //静态成员函数不能访问非静态数据成员
    {
        return rate;
    }

    //静态成员函数（设置当前利率）
    static void setRate(double setrate)
    {
        rate = setrate;
    }

    //静态成员函数获取本钱+利息
    static double show(Bank &all)
    {
        return all.money*(1+rate);
    }
};

double Bank::rate = 0.05;

int main()
{
    //获取利率
    cout << Bank::getRate() << endl;

    //设置利率
    Bank::setRate(0.04);
    cout << Bank::getRate() << endl;

    //获取本钱+利息
    Bank b(1000);
    cout << Bank::show(b) << endl;

    return 0;
}

继承

目的

  1. 实现带啊吗的复用性（重用性）
  2. 建立父类和子类之间的联系
  3. 通过继承，实现多态

概念

在已有类的基础上，增加新的特性，而构造出新类的过程，称为继承或者派生。

格式：

class 类名 ：继承方式 类名
{
    子类的拓展；
}；
//继承方式：public（共有继承） private（私有继承） protected（保护继承）
//一般继承方式为public

继承方式

父类成员访问权限                public | protected | private        public | protected | private        public | protected | private
继承方式                                public                              protected                            private
子类通过该继承方式，
父类成员被继承到子类中的访问权限  public | protected | 不可访问        protected | protected | 不可访问     private | private | 不可访问

例：

#include <iostream>

using namespace std;

//封装类
class Person    //父类（基类）
{
private:
    string name;
protected:
    int age;
public:
    string sex;

    //无参
    Person()
    {
        cout << "无参构造函数" << endl;
    }
    //有参
    Person(string n,int a,string s):name(n),age(a),sex(s)
    {
        cout << "有参构造函数" << endl;
    }
    //析构函数
    ~Person()
    {
        cout << "析构函数" << endl;
    }

    void show()
    {
        cout << "父类：" << name << " " << age << " " << sex << endl;
    }
};

//封装学生类，共有继承人类
class Stu:public Person   //子类（派生类）
{
private:
    double score;
public:
    //无参
    Stu()
    {
        cout << "子类无参构造函数" << endl;
    }
    //有参
    Stu(double s,string n,int a,string e):Person(n,a,e),score(s)
    {
        cout << "子类有参构造函数" << endl;
    }
    void show()
    {
        cout << sex << endl;      //子类可以访问从父类继承下来的共有成员
        cout << age << endl;      //子类可以访问从父类继承下来的受保护成员
        //cout << name << endl;   //子类不可以访问从父类继承下来的私有成员
    }
};

int main()
{
    Stu s(65,"zhang",18,"男");
    s.Person::show();
    return 0;
}

注意：

  • 父类的构造需要赶在子类构造之前，在书写子类的初始化列表时，需要注意先后顺序
  • 当父类和子类有同名无参函数时，它们既不是重复定义，也不是重载。（作用域不同）

多继承

概念

一个类由多个类共同派生。

格式：

class 类名：继承方式1 类名1，继承方式2 类名2，......继承方式n 类名n
{
    子类的拓展；
}；

练习

搭建一个货币的场景，创建一个名为 RMB 的类，该类具有整型私有成员变量 yuan（元）、jiao（角）和 fen（分），并且具有以下功能：

(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。

(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。

(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1

(4)重载后置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1

(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；每当销毁一个 RMB 对象时，count 应该自减 1。

要求，需要在main 函数中测试上述RMB 类的功能。

#include <iostream>

using namespace std;

//封装类
class RMB
{
private:
    int yuan;
    int jiao;
    int fen;
    int count;
public:
    //无参
    RMB()
    {
        count++;
    }
    //有参
    RMB(int y,int j,int f):yuan(y),jiao(j),fen(f)
    {
        count++;
    }
    //成员函数实现+运算符重载
    const RMB operator+(const RMB &right) const
    {
        RMB temp;
        temp.yuan = yuan + right.yuan;
        temp.jiao = jiao + right.jiao;
        temp.fen = fen + right.fen;
        return temp;
    }

    //成员函数实现-运算符重载
    const RMB operator-(const RMB &right) const
    {
        RMB temp;
        temp.yuan = yuan - right.yuan;
        temp.jiao = jiao - right.jiao;
        temp.fen = fen - right.fen;
        return temp;
    }
    //成员函数实现>运算符重载
    bool operator>(const RMB &right) const
    {
        if(yuan > right.yuan && jiao > right.jiao && fen > right.fen)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //成员函数实现前置自增运算符重载
    RMB operator--()
    {
        --yuan;
        --jiao;
        --fen;
        return *this;
    }
    //成员函数实现后置自增运算符重载
    RMB operator--(int)
    {
        RMB temp;
        temp.yuan = yuan--;
        temp.jiao = jiao--;
        temp.fen = fen--;
        return temp;
    }
    //析构函数
    ~RMB()
    {
        count--;
    }

    void show()
    {
        cout << yuan << " " << jiao << " " << fen << endl;
    }
};

int main()
{
    RMB r1(10,9,6);
    RMB r2(20,8,4);
    RMB r3 = r1 + r2;
    RMB r4 = r1 - r2;
    r1.show();
    r2.show();
    r3.show();
    r4.show();
    r1--;
    r1.show();
    --r1;
    r1.show();


    return 0;
}

仙陨
关注
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
C++常用软件分析工具从入门到精通案例集锦汇总
dvlinker的技术专栏
06-26 11万+
C++软件分析工具案例分析集锦！根据近几年C++软件异常排查的项目实践，详细地讲述如何使用PE工具、Dependency Walker、GDIView、Process Explorer、Process Monitor、API Monitor、Clumsy、DebugDiag、Windbg、IDA Pro等常用分析工具，以及如何使用这些工具去巧妙地分析和解决日常工作中遇到的问题，有很强的实战参考价值！
C++编程语言中string类介绍
liitdar的博客
08-21 31万+
string类是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和C语言的字符串之间有着良好的接口。
【C/C++】vscode配置C/C++环境
DreamSuif的博客
11-12 7万+
windows环境下vscode配置c/c++运行环境，保姆级教学，介绍了两种配置方法，以及如何解决终端乱码问题
Microsoft Visual C++ 14.0 is required.
qzzzxiaosheng的博客
06-04 10万+
解决Microsoft Visual C++ 14.0 is required报错问题，并说明常见的python包安装方法
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
C++入门基础(万字总结）（建议收藏！！！）
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++编程实例100篇
08-28
《C++编程实例100篇》是一本深入浅出的C++编程教程，它以实践为主导，通过丰富的实例帮助学习者掌握C++语言的基础和核心概念。这本书的每个实例都精心设计，旨在帮助初学者和有经验的开发者巩固和提升C++编程技能。 ...
VsCode安装和配置c/c++环境（超完整，小白专用）
热门推荐
黄化的多多
07-21 58万+
1. vsCode配置C/C++环境 1. vsCode下载和安装 1. 下载Microsoft vsCode [vsCode在这里插入图片描述官网下载: https://code.visualstudio.com/ 2. 安装vsCode 3. 下载中文插件 我这边已经下载过，刚卸载但是没有重启编译器，所以界面显示了中文 2. MinGW编译器下载和配置 1. 下载MinGW 在线安装——下载MinGW-W64-install.exe（速度慢） 下载压缩包——×86_64-posix-
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1212
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3918
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 123
【代码】C++友类匿名对象，运算符重载。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 2734
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 156
C++ | Leetcode C++题解之第390题消除游戏
C++竞赛初阶L1-15-第六单元-多维数组(34~35课)551: T456501 计算矩阵边缘元素之和
最新发布
麓小墨哥的博客
09-03 281
所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。第 1 行包含两个整数，分别为行数 m 和列数 n，两个整数之间空格隔开。第 2 行开始有 m 行数据，每行包含 n 个整数，整数之间空格隔开。输入一个整数矩阵，计算位于矩阵边缘的元素之和。对应矩阵的边缘元素和。
STL相关知识点
weixin_51927889的博客
09-03 371
主要介绍STL中容器的相关知识点
C++战列舰小游戏Lv. 1.2版本(半成品)
YYDS314的博客
08-31 1860
C++代码
C++拷贝构造函数
m0_75109289的博客
08-30 1153
设计一个Per类，类中包含私有成员:姓名、年龄、指针成员身高、体重，再设计一个Stu类，类中包含私有成员:成绩、Per类对象p1，设计这两个类的构造函数、析构函数和拷贝构造函数。
C++ | Leetcode C++题解之第388题文件的最长绝对路径
Ddddddd_158的博客
09-01 222
C++ | Leetcode C++题解之第388题文件的最长绝对路径
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值