【C++笔记5】运算符重载

最新推荐文章于 2024-09-21 12:14:27 发布
最新推荐文章于 2024-09-21 12:14:27 发布
阅读量84 收藏
点赞数
文章标签： c++ 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46703256/article/details/131295632
版权
文章详细介绍了C++中的运算符重载概念，包括不能重载的运算符、加法运算符、左移运算符、自增运算符、赋值运算符、关系运算符以及函数调用运算符的重载示例。通过成员函数和全局函数两种方式实现，并强调了重载运算符时的注意事项和应用。
摘要由CSDN通过智能技术生成

运算符重载

运算符重载的概念

运算符重载是指允许用户自定义类型的对象使用内置的运算符，或者允许用户自定义的运算符作用于内置类型的对象。运算符重载是通过函数重载来实现的。

不能重载的运算符：

.和.*运算符

::运算符

?:运算符

sizeof运算符

typeid运算符

运算符重载的基本语法

运算符重载的基本语法如下：

返回类型 operator 运算符(参数列表)
{
    //函数体
}

加法运算符重载

//运算符重载-1
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        example operator+ (example x)
        {
            cout<<"重载操作"<<endl;
            example temp(a+x.a,b+x.b);
            return temp;
        }
};
int main()
{
    example e1(1,2),e2(3,4);
    e1=e1+e1+e2+e2;
    example e3 = e1+e2;
    cout<<"e3的值";
    cout<<e3.a<<","<<e3.b<<endl;
    cout<<"e1的值";
    cout<<e1.a<<","<<e1.b<<endl;
    return 0;
}

运行结果：

初始化赋值操作
初始化赋值操作
重载操作
初始化赋值操作
重载操作
初始化赋值操作
重载操作
初始化赋值操作
重载操作
初始化赋值操作
e3的值11,16
e1的值8,12

不但可以成员函数实现 + 号运算符重载，也可以通过全局函数实现 + 号运算符重载。

//运算符重载-2
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
};
example operator+ (example x,example y)
{
    cout<<"重载操作"<<endl;
    example temp(x.a+y.a,x.b+y.b);
    return temp;
}
int main()
{
    example e1(1,2),e2(3,4);
    e1=e1+e1+e2+e2;
    example e3 = e1+e2;
    cout<<"e3的值";
    cout<<e3.a<<","<<e3.b<<endl;
    cout<<"e1的值";
    cout<<e1.a<<","<<e1.b<<endl;
    return 0;
}

初始化赋值操作
初始化赋值操作
重载操作
初始化赋值操作
重载操作
初始化赋值操作
重载操作
初始化赋值操作
重载操作
初始化赋值操作
e3的值11,16
e1的值8,12

左移(<<)运算符重载

//运算符重载-3
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        //如果需要访问私有成员，需要将重载运算符函数声明为友元函数
        friend ostream& operator<< (ostream &out,example x);
};
ostream& operator<< (ostream &out,example x)
{
    cout<<"重载<<运算符"<<endl;
    out<<x.a<<","<<x.b<<endl;
    return out;
}
int main()
{
    example e1(1,2),e2(3,4);
    cout<<e1<<e2;
    return 0;
}

输出结果：

初始化赋值操作
初始化赋值操作
重载<<运算符
1,2
重载<<运算符
3,4

自增运算符重载

//运算符重载-4（前置++）
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        example operator++ ()
        {
            cout<<"重载++运算符"<<endl;
            a++;
            b++;
            return *this;
        }
};
ostream& operator<<(ostream& out, example ex1) 
{
	out << ex1.a<<ex1.b;
	return out;
}
int main()
{
    example e1(1,2),e2(3,4);
    ++e1;
    ++e2;
    cout<<e1<<","<<e2;
    return 0;
}

输出结果：

初始化赋值操作
初始化赋值操作
重载++运算符
重载++运算符
23,45

//运算符重载-5（后置++）
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        example operator++ (int)
        {
            cout<<"重载++运算符"<<endl;
            example temp(a,b);
            a++;
            b++;
            return temp;
        }
};
ostream& operator<<(ostream& out, example ex1) 
{
	out << ex1.a<<ex1.b;
	return out;
}
int main()
{
    example e1(1,2),e2(3,4);
    e1++;
    e2++;
    cout<<e1<<e2<<endl;
    cout<<e1++<<endl;
    cout<<e1;
    return 0;
}

输出结果：

初始化赋值操作
初始化赋值操作
重载++运算符
初始化赋值操作
重载++运算符
初始化赋值操作
2345
重载++运算符
初始化赋值操作
23
34

所以说：前置递增返回引用，后置递增返回值。

赋值运算符重载

//运算符重载-6
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        example operator= (example x)
        {
            cout<<"重载赋值运算符"<<endl;
            a=x.a;
            b=x.b;
            return *this;
        }
};
ostream& operator<<(ostream& out, example ex1) 
{
    out << ex1.a<<ex1.b;
    return out;
}
int main()
{
    example e1(1,2),e2(3,4);
    e1=e2;
    cout<<e1<<e2<<endl;
    return 0;
}

输出结果：

初始化赋值操作
初始化赋值操作
重载赋值运算符
3434

关系运算符重载

//运算符重载-7
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        bool operator== (example x)
        {
            cout<<"重载==运算符"<<endl;
            if(a==x.a&&b==x.b)
                return true;
            else
                return false;
        }
        bool operator!= (example x)
        {
            cout<<"重载!=运算符"<<endl;
            if(a!=x.a||b!=x.b)
                return true;
            else
                return false;
        }
        bool operator> (example x)
        {
            cout<<"重载>运算符"<<endl;
            if(a>x.a&&b>x.b)
                return true;
            else
                return false;
        }
        bool operator< (example x)
        {
            cout<<"重载<运算符"<<endl;
            if(a<x.a&&b<x.b)
                return true;
            else
                return false;
        }
};
ostream& operator<<(ostream& out, example ex1) 
{
    out << ex1.a<<ex1.b;
    return out;
}
int main()
{
    example e1(1,2),e2(3,4);
    if(e1==e2)
        cout<<"e1==e2"<<endl;
    else
        cout<<"e1!=e2"<<endl;
    if(e1!=e2)
        cout<<"e1!=e2"<<endl;
    else
        cout<<"e1==e2"<<endl;
    if(e1>e2)
        cout<<"e1>e2"<<endl;
    else
        cout<<"e1<=e2"<<endl;
    if(e1<e2)
        cout<<"e1<e2"<<endl;
    else
        cout<<"e1>=e2"<<endl;
    return 0;
}

输出结果：

初始化赋值操作
初始化赋值操作
重载==运算符
e1!=e2
重载!=运算符
e1!=e2
重载>运算符
e1<=e2
重载<运算符
e1<e2

函数调用运算符重载

//运算符重载-8
#include<iostream>
using namespace std;
class example
{
    public:
        int a;
        int b;
        example(int x,int y):a(x),b(y)
        {
            cout<<"初始化赋值操作"<<endl;
        }
        example operator() (example x)
        {
            cout<<"重载()运算符"<<endl;
            a=x.a;
            b=x.b;
            return *this;
        }
};
ostream& operator<<(ostream& out, example ex1) 
{
    out << ex1.a<<ex1.b;
    return out;
}
int main()
{
    example e1(1,2),e2(3,4);
    e1(e2);
    cout<<e1<<","<<e2<<endl;
    return 0;
}

输出结果：

初始化赋值操作
初始化赋值操作
重载()运算符
34,34

其他运算符略

重载运算符的注意事项

  1. 重载运算符不能改变运算符的优先级和结合性
  2. 重载运算符不能创建新的运算符
  3. 重载运算符不能改变运算符的操作数个数
  4. 重载运算符不能改变运算符的操作数类型
  5. 重载运算符不能改变运算符的操作数的含义

重载运算符的应用

  1. 重载运算符可以使得类的对象像内置类型一样使用，如：cin、cout、+、-、、/、==、!=、>、<、++、–、=、()、[]、&、|、~、!、<<、>>、+=、-=、=、/=、<<=、>>=、&=、^=、|=、,、->、->*、new、delete、new[]、delete[]等；
美丽新科技
关注
C++笔记之运算符重载笔记(以+号为例)
小勇博客
06-17 46
C++笔记之运算符重载笔记(以+号为例) 文章目录C++笔记之运算符重载笔记(以+号为例)1.加号运算符重载为类的成员函数2.加号运算符重载为类的友元函数3.加号运算符重载为普通函数三种情况分析对比一般函数 1.加号运算符重载为类的成员函数 2.加号运算符重载为类的友元函数 3.加号运算符重载为普通函数 三种情况分析 对比一般函数
C++[运算符重载]
qq_43281363的博客
03-11 582
学习笔记
04-02 对象数组
weixin_50755913的博客
11-04 144
对象数组 【Example 1】 #include <iostream> using namespace std; class exam { private: int x; public: void set_x(int n) { x = n; } int get_x() { return x; } }; int main() { exam ob[4]; int i; for (i = 0; i <
3-1 Point类的构造函数(构造函数的重载)
Rocky0429
09-15 3859
3-1 Point类的构造函数 Time Limit: 1000MS Memory limit: 65536K 题目描述 通过本题目的练习可以掌握类的构造函数的定义； 设计一个点类Point，私有数据成员有x、y；公有成员函数有：无参数的构造函数Point()，带参数的构造函数Point(int,int);ShowPoint()输出点对象的信息 在主函数main()中
C++第三章习题
C++ Primer 学习
06-20 1737
C++第三章习题 写出程序的运行结果： #include <iostream> using namespace std; class toy { public: toy(int q, int p) { quan = q; price = p; } int get_quan() { return quan; } int get_price() { return price; } private: int quan
构造函数初始化列表
九灵猴君的博客
06-26 759
C++之构造函数初始化列表介绍
C++构造函数
mt_lf的专栏
03-19 220
构造函数 构造函数并不负责空间，它只是用来初始化成员变量． 当用户没有定义构造函数时，编译常生成默认构造函数，默认构造函数不进行任何操作． 一个类可以有多个构造函数．多个构造函数之间成重载关系． #include <iostream> using namespace std; class Sample { int x; public: Sample(...
C++笔记之运算符重载详解
小笨聪
05-22 771
本文主要内容：一.运算符重载简介1.运算符重载实质2.规则和限制二.运算符的重载形式1.重载为类成员函数2.重载为友元函数3.特殊介绍 一.运算符重载简介 1.运算符重载实质 (1) 对已有的运算符赋予多重含义 (2) 必要性：C++预定义的运算符运算对象只能是基本数据类型，而不适用于用户自定义类型（如 类） (3) 实现机制： 将指定的运算符表达式转化为对运算符函数的调用，运算对象转化运算符函数的实参。 编译系统对重载运算符的选择，遵循函数重载的选择原则。 2.规则和限制 (1) 可以重载的运算符：
P121~126C++类和对象C++运算符重载学习笔记.docx
04-13
C++运算符重载学习笔记 C++类和对象是面向对象编程的基础概念。运算符重载是C++中的一种重要机制，允许开发者重新定义已有的运算符，赋予其新的功能，以适应不同的数据类型。在本文中，我们将详细介绍C++运算符重载...
C++运算符重载(插入and提取)
ciao_21的博客
12-30 580
本文主要介绍 插入(>>) and 提取(
C++ 面向对象（一）—— 类（Classes）
知秋一叶
05-22 3万+
类(class)是一种将数据和函数组织在同一个结构里的逻辑方法。定义类的关键字为class ，其功能与C语言中的struct类似，不同之处是class可以包含函数，而不像struct只能包含数据元素。 类定义的形式是： class class_name { permission_label_1: member1; permis
习题（针对学习笔记16-30）
aaqian1的博客
11-30 2438
1、什么是对象数组？ https://blog.csdn.net/aaqian1/article/details/84061049 2、什么是 this 指针？它的主要作用是什么？ https://blog.csdn.net/aaqian1/article/details/84137285 3、友元函数有什么作用？ https://blog.csdn.net/aaqian1/article/det...
C++中对私有成员变量进行赋值
积累点滴，保持自我
04-26 2万+
c++类成员的访问属性可以分为三种，分别是：公共成员（public），私有成员（private），受保护成员（protected）。在类对象的作用域内，公共成员在类的外部是可访问的。私有成员和受保护成员则不可以直接访问。下面一个小例子，使用公有成员函数对私有成员进行赋值：class example { public: int a; int set(int b) { return c = ...
C++类(Class)的定义与实现
热门推荐
xulingxin的博客
08-01 26万+
一、"类" 的介绍     在C++中, 用 "类" 来描述 "对象", 所谓的"对象"是指现实世界中的一切事物。那么类就可以看做是对相似事物的抽象, 找到这些不同事物间的共同点, 如自行车和摩托车, 首先他们都属于"对象", 并且具有一定得相同点, 和一些不同点, 相同点如他们都有质量、都有两个轮子, 都是属于交通工具等。"都有质量"、"两个轮子"属于这个对象的属性,
Class example in C/C++
玮哥的博客
03-18 1043
class Player {  private:   int health; //these are the attributes   int strength;   int agility;  public: void move(); void attackEnemy(); //these are the method prototypes void getTre
C++类模板example
Hello World
04-28 1108
C++类模板example 这里主要是参考了Essential C++书籍中的做法，对Matrix类做了一个简单的实现 主要涉及的内容有：类模板、函数模板、操作运算符重载，友元函数等 注意 有些运算符可以有多种实现方式，比如+，*，可以实现类内的一元操作符重载，也可以以友元函数的形式实现二元操作符的重载(这里采用的方式) 在类中声明友元函数模板时，需要重新使用一个模板名，否则会出现un...
class example of C++
玮哥的博客
04-08 1525
#include using namespace std; class Rectangle {     int width, height;   public:     void set_values (int,int);     int area() {return width*height;} }; void Rectangle::set_values (int x,
Some Example For C++
qq_27004823的博客
09-17 343
ex1:阶乘的实现 #include const int  Arsize=16; int main() { long long factorials[ArSize]; factorials[1]=factorials[0]=1; for(int i=2;i factorials[i]=i*factorials[i-1]; for(int i=0;i std::cout sy
C语言中union的用法
最新发布
zyqash的博客
09-21 424
在C语言中，union（联合体）是一种特殊的复合数据类型，它允许多个不同的数据成员共享同一块内存空间。与struct（结构体）不同的是，union中的所有成员共用同一个内存地址，因此同时只能存储一个成员的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

美丽新科技

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值