小白学习，c++基础（八）重载运算符

最新推荐文章于 2024-07-12 16:34:36 发布
最新推荐文章于 2024-07-12 16:34:36 发布
阅读量266 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46466935/article/details/105104628
版权

小白学习

1、可重载的运算符

在这里插入图片描述

2、重载自增或自减++ - -运算符

operator++
编译器看到++a(前置++)，它就调用operator++(a),当编译器看到a++（后置++），它就会去调用operator++(a,int).

#include <iostream>

using namespace std;
class Data
{
    friend ostream& operator<<(ostream &out, Data &ob);
private:
    int a;
    int b;
public:
    Data()
    {
        cout<<"无参的构造函数"<<endl;
        a = 0;
        b=0;
    }
    Data(int a,int b):a(a),b(b)
    {
        cout<<"有参构造"<<endl;
        //this->a = a;
        //this->b = b;
    }
    void showData(void)
    {
        cout<<"a = "<<a<<", b= "<<b<<endl;
    }
    ~Data()
    {
        cout<<"析构函数函数"<<endl;
    }

    //成员函数 重载前置++  ++ob1  (先加  后使用)
    //编译器 默认识别 operator++(a) //但是a可以用this代替 从而化简 operator++()
    Data& operator++()//++ob1
    {
        //先加
        a++;//this->a = this->a +1
        b++;//this->b = this->b +1
        //后使用
        return *this;
    }
    //成员函数 重载后置++  ob1++  (先使用 后加)
    //编译器 默认识别 operator++(a,int) //但是a可以用this代替 从而化简 operator++(int)
    Data& operator++(int)//ob1++
    {
        //先使用(备份加之前的值)
        static Data old=*this;

        //后加
        a++;
        b++;

        //返回备份值
        return old;
    }

    //重载前置--    --ob3
    //编译器 默认识别 operator++(a) //但是a可以用this代替 从而化简 operator--()
    Data& operator--()
    {
        //先减
        a--;
        b--;

        //后使用(返回)
        return *this;
    }

    //重载后--    ob4--
    //编译器 默认识别 operator++(a,int) //但是a可以用this代替 从而化简 operator++(int)
    Data& operator--(int)
    {
        //先使用
        static Data old=*this;

        //再减
        a--;
        b--;

        return old;
    }


};
//普通全局函数 作为类的友元 重载<<运算符
ostream& operator<<(ostream &out, Data &ob)
{
    out<<"a = "<<ob.a<<", b = "<<ob.b;
    return out;
}
void test01()
{
    Data ob1(10,20);
    ob1.showData();

    //重载<<直接输出自定义对象的值
    //operator<<(cout,ob1);
    cout<<ob1<<endl;

    //成员函数 重载 ++运算符
    cout<<++ob1<<endl;

    Data ob2(10,20);
    cout<<ob2++<<endl;
    cout<<ob2<<endl;

    //成员函数 重载 --运算符
    Data ob3(10,20);
    cout<<"ob3 "<<ob3<<endl;
    cout<<--ob3<<endl;

    Data ob4(10,20);
    cout<<"ob4 "<<ob4<<endl;
    cout<<ob4--<<endl;
    cout<<"ob4 "<<ob4<<endl;


}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

3、指针运算符* ->

#include <iostream>

using namespace std;
class Person
{
private:
    int num;
public:
    Person(int num):num(num)
    {
        //this->num = num;
        cout<<"有参构造num = "<<num<<endl;
    }

    void showPerson(void)
    {
        cout<<"num = "<<num<<endl;
    }
    ~Person()
    {
        cout<<"析构函数 num = "<<num<<endl;
    }
};

//设计一个智能指针 解决 Person new出的堆区空间 释放问题
class SmartPointer{
public:
    Person *pPerson;
public:
    SmartPointer(Person *p)
    {
        pPerson = p;
    }

    ~SmartPointer()
    {
        if(pPerson != NULL)
        {
            delete pPerson;
            pPerson = NULL;
        }
    }

    //成员函数重载->运算符
    Person* operator->()
    {
        return this->pPerson;
    }

    //成员函数 重载 *运算
    Person& operator*()
    {
        return *(this->pPerson);
    }
};
void test01()
{
    Person *p = new Person(100);
    p->showPerson();

    //假如我忘了 delete p
    //delete p;

    //需求：自动的帮我释放 堆区空间（智能指针的概念）
    SmartPointer pointer(new Person(200));

    //访问Person类中的showPerson()
    //pointer.pPerson->showPerson();

    //保证指针的使用
    //(pointer.operator ->())->showPerson();
    pointer->showPerson();
    (*pointer).showPerson();
    
}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

4、重载=运算符

前提1：类中 没有指针成员 不需要重载=运算符（默认的浅拷贝就可以完成）

#include <iostream>

using namespace std;
class Person
{
private:
    int a;
    int b;
public:
    Person():a(0),b(0)
    {
        cout<<"无参构造"<<endl;
    }
    Person(int a, int b):a(a),b(b)
    {
        cout<<"有参构造"<<endl;
    }
    void showPerson(void)
    {
        cout<<"a = "<<a<<", b = "<<b<<endl;
    }
    ~Person()
    {
        cout<<"析构函数"<<endl;
    }
};
void test01()
{
    Person ob1(10,20);
    ob1.showPerson();

    //注意 旧对象 给新对象赋值 调用的是拷贝构造（默认拷贝构造就是单纯的赋值）
    Person ob2 = ob1;//这个地方 可不是调用赋值=运算符
    ob2.showPerson();

    Person ob3;
    ob3 = ob1;//此处才是调用的赋值=运算符(默认赋值=运算是浅拷贝) 
    ob3.showPerson();
}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

前提2：类中 有指针成员 必须重载=运算符
指针作为类的成员：
1、拷贝构造函数 必须自定义（默认拷贝构造 是浅拷贝）
2、必须重载=运算符 （默认=号运算符 是浅拷贝）

#include <iostream>
#include<string.h>
using namespace std;
class Person
{
private:
    char *name;//指针成员
public:
    Person()
    {
        name = NULL;
        cout<<"无参构造"<<endl;
    }
    Person(char *name)
    {
        //根据实际传入的 参数 给this->name申请空间
        this->name = new char[strlen(name)+1];

        //将name指向的字符串 拷贝到  this->name指向的空间中
        strcpy(this->name,name);

        cout<<"有参构造"<<endl;
    }
    Person(const Person &ob)//ob代表的就是旧对象
    {
        //this代表的是新对象
        cout<<"拷贝构造函数"<<endl;
        this->name = new char[strlen(ob.name)+1];
        strcpy(this->name, ob.name);
    }


    ~Person()
    {
        cout<<"析构函数"<<endl;
        if(this->name != NULL)
        {
            delete [] this->name;
            this->name = NULL;
        }
    }

    void showPerson(void)
    {
        cout<<"name = "<<name<<endl;
    }
    //成员函数 重载=运算符
    Person& operator=(Person &ob)//ob == ob1
    {
        //this ==>&ob3
        if(this->name != NULL)//说明this->name 以前有指向(重点)
        {
            //释放以前指向的空间
            delete [] this->name;
            this->name = NULL;
        }

        //申请空间
        this->name = new char[strlen(ob.name)+1];
        //拷贝内容
        strcpy(this->name,ob.name);

        return *this;//重点
    }
};

void test01()
{
    Person ob1("lucy");
    ob1.showPerson();

    Person ob2 = ob1;//调用拷贝构造

    Person ob3("bob");
    //不重载 = 默认是浅拷贝
    ob3 = ob1;

    ob3.showPerson();

    Person ob6,ob5,ob4;
    ob6 = ob5 = ob4 = ob1;
    ob6.showPerson();
}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

5、等于和不等于（==、！=）运算符重载

//重载==  ==出现在判断语句中
    bool operator==(Person &ob)
    {
        if(strcmp(this->name, ob.name) == 0)
        {
            return true;
        }
        return false;
    }
    //重载!=  !=出现在判断语句中
    bool operator!=(Person &ob)
    {
        if(strcmp(this->name, ob.name) != 0)
        {
            return true;
        }
        return false;
    }

6、函数调用符（）的重载

#include <iostream>

using namespace std;
class Fun
{
public:
    int my_add(int x,int y)
    {
        return x+y;
    }
    //重载()
    //第一个()是重载的符号 第二个（）是标明要传参
    int operator()(int x,int y)
    {
        return x+y;
    }
};

void test01()
{
    Fun fun;
    cout<<fun.my_add(100,200)<<endl;

    cout<<fun.operator ()(100,200)<<endl;
    //优化 fun和（）结合 就会自动寻找()运算符
    cout<<fun(100,200)<<endl;
    //此处 fun(100,200)不是一个真正的函数 仅仅是一个对象名和()结合 调用（）重载运算符而已
    //fun不是函数名 只是fun（100,200）类似一个函数调用 所以将fun（100,200）叫做仿函数

    //此处的Fun是类名称
    //Fun()匿名对象 Fun()(100,200) 就是匿名对象(100,200)
    cout<<Fun()(100,200)<<endl;//了解

}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

7、不要重载&&、||

不要重载&&、|| 因为 用户无法实现 && ||的短路特性。
&& 短路特性： A && B 如果A为假 B将不会执行
|| 短路特性： A || B 如果A为真 B将不会执行

总结：

在这里插入图片描述

小白的骑士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言friend函数,C++中的friend函数详细解析
weixin_34190683的博客
05-20 1017
为什么要使用友元函数在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员(例如：智能指针类的实现)，那么类A中该函数要是类B的友元函数。具体来说：为了使其他类的成员函数直接访问该类的私有变量。即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。实际上具体大概有下面两种情况需要使用友元函数：(1)运算符重载的某些场合需要使用友元。(2)两个类要...
小白学习C++之重载递减运算符
zuoyiyi的博客
11-16 156
VS2010-C++重载递减运算符实现 /*1.友元-让一个函数或者类访问另一个类中私有成员 三种类型：全局函数做友元 友元类 成员函数做友元 2.运算符重载-对已有运算符重新进行定义，赋予其另外一种功能，以适应不同的数据类型 */ #include<iostream>//标准输入/输出流对象头文件 using namespace std;//使用C++标准程序库的标识符声明 //自定义整型 class Myinteger { friend ostream& operator&lt
重载operator<<操作符—friend ostream& operator<<(ostream&,const Date&);
热门推荐
小伟锅的博客
07-31 2万+
利用friend友元函数对操作符 #include using namespace std; class Date { friend ostream& operator<<(ostream&,const Date&); int year; int month; int day; public: Date() {year=2013; month=
java 友元函数_C++中的friend友元函数详细解析
weixin_29457191的博客
02-24 409
友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend。我们已知道类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特...
C++中的类模板应用问题
石头的专栏
10-29 797
在C++中，类模板的使用有一些特殊的问题，大家都知道，C++中类的出现是为了实现封装，达到信息的隐藏，很多时候，类的声明和实现细节是分到不同的文件进行编写的，但是在模板中，因为一些特殊的原因（对模板参数无法分辨），必须要将两部分写道同一个文件中，并且，因为模板的复杂性，其默写特殊形式的声明也比较特别。下例为网上摘录的一个片段（其中做了部分修改，另，因为记不得准确的出处，所以不知道该怎么声明，还请原
【C++初阶】ostream&、operater＜＜、operator＜＜(ostream& _cout, const Date& d)、bool引导的结构体内嵌比较函数解析
Captain_ldx的博客
04-02 1129
以日期类为例，对C++自定义类重载、判断部分的知识进行梳理
C++小白学习之关系运算符重载
zuoyiyi的博客
11-17 85
关系运算符重载-让两个自定义类型对象进行对比操作 #include<iostream>//标准输入/输出流对象头文件 using namespace std;//使用C++标准程序库的标识符声明 #include <string> class Person//定义一个类 { public: Person (string name,int chinese,int math)//析构函数赋值 { m_Name = name; m_Chinese = chinese; m_
基于 C++实现的教室管理系统 （课程设计报告+源码）
06-26
【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 序运用面向对象编程思想进行设计。核心有教室类、预约信息类、上课信 ...
C++ MFC 简单计算器（完善+注释）
09-19
总的来说，C++ MFC简单计算器的实现涉及到了C++基础、面向对象编程、MFC框架理解和Windows程序设计等多个方面。通过这个项目，开发者可以提升在这些领域的技能，并了解如何将理论知识应用于实际软件开发中。同时，...
基于 C++实现的宠物小精灵游戏票【面向对象课程设计】（课程设计报告+源码）
06-27
【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 一．基础实验 1.编写C++程序完成“矩阵”相加减 2.(1)编写C++程序...
C++课程-高质量C++编程_课时_大纲
08-25
- **3.1 函数定义与调用**：理解函数的作用，学习函数参数、返回值以及函数重载。 - **3.2 变量作用域与存储类别**：解释局部变量、全局变量、静态变量和extern关键字。 - **3.3 函数指针**：理解函数指针的使用，...
friend ostream& operator < <
日月行者的专栏
10-13 1136
friend ostream& operator    friend 友元函数   ostream&返回值   operator   ostream& pOs------参数一 SysCmnInfoElement& pObj---参数二     以后，使用cout
20、C++运算符重载之输入输出运算符的重载
xuxianmei的专栏
04-28 4577
C++运算符重载之输入输出运算符的重载 系统对于自定义类型的输入输出，采用重载后的运算符 >来实现。 1、重载插入运算符(也称输出运算符)   一般格式： ostream   &  operator  { out return out; } 2、重载提取运算符(也称输入运算符) >> 一般格式：但是返回类型不一定为这个类型。 istream & operator   >>(i
8-函数重载分析(上)
老姚大大
05-24 218
8-函数重载分析(上) 重载的概念重载：同一个标识符在不同的上下文有不同的意义C++中的重载函数函数重载：用同一个函数名定义不同的函数当函数名和不同的参数搭配时函数的含义不同int func(int x) { return x; } int func(int a, int b) { return a + b; } int func(const char* s) { re...
java基础改学C++（八）运算符重载
Eric's Blog
05-14 466
java基础改学C++（八）运算符重载
函数模板与类模板
程序员_小兵
07-12 1554
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
最新发布
I_feige的博客
07-12 321
1.
C++ 多态
wxk2227814847的博客
07-10 790
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值