C++基础笔记整理（运算符重载） 第二篇

最新推荐文章于 2024-11-11 23:32:39 发布
最新推荐文章于 2024-11-11 23:32:39 发布
阅读量96 收藏
点赞数
文章标签： c++ 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luan_qd/article/details/128637130
版权

1.友元

1.1 概念

类实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，仅能通过类的成员函数才能读写。如果数据成员定义为公共的，则又破坏了封装性。但是某些情况下，需要频繁读写类的数据成员，特别是在对某些成员函数多次调用时，由于参数传递、类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。

友元是一种定义在类外部的普通函数，但他需要在类内进行说明，为了和该类的成员函数加以区别，在说明时前面加以关键字friend

学习友元最终的目的是把友元运用在运算符重载上，其它情况下不要使用友元，因为会破坏面向对象的特性。

友元主要分为以下几种使用情况：

● 友元函数

● 友元类

● 友元成员函数

1.2友元函数

友元函数是一种类外的函数，但是需要在类内结合friend关键字进行说明（非声明），需要注意以下几点：

● 因为友元函数不是类内的函数，因此没有this指针，因此需要给友元函数增加一个传递对象的参数位，用此对象来调用类中的成员。

● 友元函数不属于类，因此不受类中权限修饰符的影响，即友元函数的说明可以放在类中的任意位置。

● 一个友元函数可以访问多个类的成员，只需要在多个类中分别说明。

#include <iostream>

using namespace std;

class Test
{
private:
    int a = 1;

    // 友元函数的说明，放在类中的任意位置都可以
    friend void test_friend(Test& t);
};

// 友元函数在类外
void test_friend(Test& t)
{
    t.a++;
    cout << t.a << endl;
}

// 不是友元函数
void test(Test& t)
{
//    t.a++; 错误
//    cout << t.a << endl; 错误
}

int main()
{
    Test t;
    test_friend(t); // 2

    return 0;
}

1.3友元类

当一个类B成为了另一个类A的“朋友”时，类A的所有成员就可以被类B访问，此时类B是类A的友元类。

#include <iostream>

using namespace std;

class A
{
private:
    int i = 1;

    // 进行友元类的说明
    friend class B;
};

class B
{
public:
    void func(A& a) // func函数中的this指针是B对象
    {
        a.i++;
        cout << a.i << endl;
    }
};

int main()
{
    A a;
    B b;
    b.func(a); // 2

    return 0;
}

需要注意的是：

● 友元关系是单向的，不具有交换性。

● 友元关系不具有传递性。

● 友元关系不能被继承。

1.4友元成员函数

可以使类B中的某一个成员函数成为类A的友元成员函数，这样类B中只有这个成员函数可以访问类A的所有成员。

using namespace std;

// 第三步
class A;

// 第二步
class B
{
public:
    void func(A& a); // 先只声明
};

// 第一步
class A
{
private:
    int i = 1;

    // 说明友元成员函数
    friend void B::func(A& a);
};

// 第四步，补齐友元函数的定义
void B::func(A &a)
{
    a.i++;
    cout << a.i << endl;
}

int main()
{
    A a;
    B b;
    b.func(a); // 2

    return 0;
}

2.运算符重载

2.1概念

函数可以重载，运算符也是一种特殊的函数，因此运算符也可以重载。

函数的组成部分：

● 名称

● 输入参数

● 函数体

● 返回值

上述的每个组成部分运算符都拥有。

C++中的运算符默认的操作类型只支持基本数据类型，例如+支持整型浮点型等类型的运算，但是对于很多用户自定义的类型（Dog类、Cat类、Test类等）的对象也需要支持运算符，例如 狗+狗。此时可以在代码中重载运算符，赋予这些运算符处理新的类型的功能。

可以被重载的运算符：

算术运算符：+、-、*、/、%、++、--

位操作运算符：&、|、~、^(位异或)、<<(左移)、>>(右移)

逻辑运算符：!、&&、||

比较运算符：<、>、>=、<=、==、!=

赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=

其他运算符：[]、()、->、,、new、delete、new[]、delete[]

不被重载的运算符：

成员运算符 .、指针运算符 *、三目运算符 ? :、sizeof、作用域 ::

2.2友元函数运算符重载

可以使用友元函数进行运算符重载。

#include <iostream>

using namespace std;

/**
 * @brief The Integer class
 * 整型类
 */
class Integer
{
private:
    int value;

public:
    Integer(int value):value(value){}

    int get_value() const
    {
        return value;
    }

    // 友元函数的说明
    friend Integer operator +(const Integer& i1,
                              const Integer& i2); // 双目
    friend Integer operator ++(Integer& i); // 单目,前置
    friend Integer operator ++(Integer& i,int); // 单目,后置
};

Integer operator +(const Integer& i1,
                   const Integer& i2)
{
    return i1.value+i2.value;
}

Integer operator ++(Integer& i)
{
    return ++i.value;
}

Integer operator ++(Integer& i,int)
{
    return i.value++;
}

int main()
{
    Integer i1(1);
    Integer i2(2);
    Integer i3 = i1+i2;
    cout << i3.get_value() << endl; // 3

    cout << (i1++).get_value() << endl; // 1
    cout << i1.get_value() << endl; // 2
    cout << (++i2).get_value() << endl; // 3

    return 0;
}

2.3成员函数运算符重载

也可以使用成员函数进行运算符重载，成员函数的运算符函数对应的输入参数比同样使用友元函数实现的友元函数的参数少一个。

using namespace std;

/**
 * @brief The Integer class
 * 整型类
 */
class Integer
{
private:
    int value;

public:
    Integer(int value):value(value){}

    int get_value() const
    {
        return value;
    }

    // 成员函数运算符重载
    Integer operator +(const Integer& i);
    Integer operator ++(); // 前置
    Integer operator ++(int); // 后置
};

Integer Integer::operator +(const Integer& i)
{
    // this表示运算数1
    return this->value+i.value;
}

Integer Integer::operator ++()
{
    return ++this->value;
}

Integer Integer::operator ++(int)
{
    return this->value++;
}

int main()
{
    Integer i1(1);
    Integer i2(2);
    Integer i3 = i1+i2;
    cout << i3.get_value() << endl; // 3

    cout << (i1++).get_value() << endl; // 1
    cout << i1.get_value() << endl; // 2
    cout << (++i2).get_value() << endl; // 3

    return 0;
}

2.4其他运算符重载

2.4.1赋值运算符重载

如果写一个空类，按照目前所学内容，编译器会自动添加：

● 无参构造函数

● 析构函数

● 拷贝构造函数

除了上述三者外，编译器还会增加若干内容，其中包括赋值运算符重载函数。

赋值运算符重载函数只支持成员函数运算符重载，不支持友元函数运算符重载的方式。

using namespace std;

class Teacher
{
public:
    string subject;

    Teacher(string sub)
    {
        subject = sub;
    }

    // 编译器自动添加赋值运算符重载函数
    Teacher& operator =(const Teacher& right)
    {
        this->subject = right.subject;
        cout << "赋值运算符：" << subject << endl;
        return *this;
    }
};

int main()
{
    Teacher t1("C++");
    Teacher t2("C#");
    t2 = t1; // 赋值操作

    cout << (t2 = t1).subject << endl; // 支持链式调用
    cout << t2.subject << endl; // C++

    t2.subject = "C";
    Teacher t3 = t2; // 隐式调用拷贝构造函数
    cout << t3.subject << endl; // C

    return 0;
}

通常无需手动编写赋值运算符重载，以下情况需要手动编写，编译器不在自动添加赋值运算符重载函数：

● 当前类的成员变量出现指针

● 屏蔽赋值运算符的使用（权限为private）

2.4.2类型转换运算符重载

可以使自定义类型的对象自动转换为任意类型，此函数也只能使用成员函数运算符重载。

using namespace std;

class Teacher
{
public:
    string subject;

    Teacher(string sub)
    {
        subject = sub;
    }

    operator string() // 格式比较特殊
    {
        return subject;
    }
};

int main()
{
    Teacher t("语文");
    string s = t;
    cout << s << endl; // 语文

    return 0;
}

2.5注意事项

● 运算符重载限制在C++已有的运算符范围内，不允许创建新的运算符。

● 运算符重载也是函数重载，运算符也是函数。

● 重载之后的运算符不能改变优先级和结合性。

● 重载之后的运算符不能改变操作数和语法结构。

● 运算符重载不能改变该运算符用于基本数据类型的含义，但是可以把基本数据类型与自定义类型一起运算，或者都使用自定义类型。

● 运算符重载是针对新类型数据的实际需要对原有运算符的功能进行扩充，因此重载之后的功能应该与原有的功能类似，避免没有目的地使用运算符重载。

● 通常建议单目运算符使用成员函数运算符重载，双目运算符使用友元函数运算符重载。

3.字符串类 std::string

再学习此类，主要涉及此类的一些构造函数和成员函数。

std::string是一种特殊容器的类型，用于操作字符序列。

#include <iostream>
#include <string.h>

using namespace std;


int main()
{
    string s; // 创建一个内容为空的字符串对象
    // 是否为空
    cout << s.empty() << endl; // 1
    // 隐式调用构造函数
    string s1 = "Abc";
    // 相当于
    string s2("Abc");
    cout << (s1 == s2) << endl; // 1

    // 拷贝构造函数
    string s3 = s2;
    string s4(s3);

    cout << s3 << " " << s4 << endl; // Abc Abc

    // 参数1：源字符串 char*
    // 参数2：从前往后保留的字符数
    string s5("ABCDEFG",3);
    cout << s5 << endl; // ABC

    // 参数1：源字符串 string
    // 参数2：从前往后不保留的字符数
    s = "ABCDEFG";
    string s6(s,3);
    cout << s6 << endl; // DEFG

    // 参数1：字符数量
    // 参数2：字符 char
    string s7(5,'A');
    cout << s7 << endl; // AAAAA

    // 交换
    swap(s6,s7);
    cout << s6 << " " << s7 << endl; // AAAAA DEFG

    s1 = "ABCD";
    // 向后追加字符串，支持链式调用
    s1.append("EF").append("GHI").append("ZZZ"); // ABCDEFGHIZZZ
    cout << s1 << endl;

    // 字符串连接
    s1 = s6+s7;
    cout << s1 << endl; // AAAAADEFG

    // 向后追加一个字符
    s1.push_back('*');
    cout << s1 << endl; // AAAAADEFG*

    // 参数1：插入的位置
    // 参数2：插入的内容
    s1.insert(1,"###");
    cout << s1 << endl; // A###AAAADEFG*

    // 参数1：替换的起始位置
    // 参数2：替换的字符数量
    // 参数3：替换的新内容
    s1.replace(0,7,"!!!!");
    cout << s1 << endl; // !!!!ADEFG*

    // 参数1：删除的起始位置
    // 参数2：删除的字符数
    s1.erase(4,3);
    cout << s1 << endl; // !!!!FG*

    // 清空
    s1.clear();
    cout << s1.length() << endl; // 0

    // C字符串→C++字符串
    char c[20] = "hello";
    s = c;
    cout << s << endl; // hello

    // C++字符串→C字符串
    s = "Good afternoon!";
//    c = s; 错误
    s.copy(c,s.size()); // 全拷贝
    cout << c << endl; // Good afternoon!
    // 参数1：源字符串
    // 参数2：拷贝的数量
    // 参数3：拷贝的起始位置
    s.copy(c,9,5);
    cout << c << endl; // afternoonrnoon!

    // 还可以使用下面的函数完成
    char d[20];
    strcpy(d,s.c_str()); // c_str()返回一个临时的const char*
    cout << d << endl; // Good afternoon!

    return 0;
}
luan_qd
关注
C++重温笔记(六): 运算符重载
Miracle8070
10-18 1410
1. 写在前面 c++在线编译工具，可快速进行实验: https://www.bejson.com/runcode/cpp920/ 这段时间打算重新把c++捡起来， 实习给我的一个体会就是算法工程师是去解决实际问题的，所以呢，不能被算法或者工程局限住，应时刻提高解决问题的能力，在这个过程中，我发现cpp很重要， 正好这段时间也在接触些c++开发相关的任务，所有想借这个机会把c++重新学习一遍。 在推荐领域， 目前我接触到的算法模型方面主要是基于Python， 而线上的服务全是c++(算法侧， 业务那边基本上
C++类细节梳理之运算符重载
dislike_shuati的博客
04-13 1470
c++类的运算符重载的学习笔记及知识点整理
C++基础笔记整理（STL编程） 第三篇
luan_qd的博客
01-11 88
关于C++ STl编程笔记整理
C++快速入门13-运算符重载
qq_34740116的博客
04-24 210
本系列博客是我假期在B站花了一天时间看了一个快速入门C++的视频，大概是4个小时，不过来回截图，整理笔记也花了一大整天； 13. 运算符重载 在平时项目中，有时候需要自定义一些常规的运算符给某个功能用，那么就必须重新定义这个符号的功能了。 有些运算符可以作为成员函数，有些运算符只能作为外部函数； 比如输入输出流函数只可作为外部函数；加法运算符既可以作为成员函数，也可以作为外部函数。 示例1-问题引...
C++的运算符重载(2)
小嵌同学的博客
12-25 831
目录一、赋值运算符重载函数返回引用1、返回引用好处1：提升程序效率2、返回引用好处2：允许连续赋值式3、思考：传参为什么要传引用二、String类的赋值运算符重载1、标准库中String类的运算符重载2、String的=运算符重载演练3、总结三、++和--运算符的前置后置如何实现1、可前置可后置的运算符2、如何重载++和3、总结四、两种运算符重载方法1、并非所有运算符都支持重载2、并非只有一种方式实现重载3、如何选择两种运算符重载 一、赋值运算符重载函数返回引用 1、返回引用好处1：提升程序效率 (1)赋值
C++初学笔记整理
m0_62918577的博客
03-05 738
c++初学整理 1. C++关键字 2. 命名空间 3. C++输入&输出 4. 缺省参数 5. 函数重载 6. 引用 7. 内联函数 8. auto关键字(C++11) 9. 基于范围的for循环(C++11) 10. 指针空值---nullptr(C++11)
C++笔记基础全部完整版
Bei_Chen的博客
09-04 1216
被继承的类叫做基类（父类），继承的类叫派生类（子类），在派生类类名后面加 : 继承方式，基类子类包含且可以使用父类的成员.//继承：子类包含且可以使用父类的成员public:int m_a;m_b = 20;//子类可以直接使用父类的成员//当子类成员和父类成员同名时，在成员前面加上作用域得以区分，默认是子类int main()CSon p1;p1.show();
C++基础笔记整理 第一篇
luan_qd的博客
01-10 75
C++笔记整理
C++ 运算符重载_c++ 重载=，2024年最新面试学习
2401_84240554的博客
04-13 960
学起的朋友，同时减轻大家的负担。**[外链图片转存中…(img-8fLI0FvW-1712955609251)][外链图片转存中…(img-nqlgXORn-1712955609253)][外链图片转存中…(img-7IfP93US-1712955609254)][外链图片转存中…(img-MKBSC8Ov-1712955609254)][外链图片转存中…(img-2qFRMFfe-1712955609255)]
计算机二级C++关键考点笔记整理
04-04
### 计算机二级C++关键考点笔记整理 #### Strcpy用法 `strcpy`是一个字符串复制函数，用于将一个字符串的内容复制到另一个字符串中。它的语法通常如下： ```c++ strcpy(destination, source); ``` 这里`destination...
C++复习笔记简单整理
06-28
// 第二个版本 ``` **注意事项**： - 返回类型不能用于区分重载函数。 - 参数列表必须不同。 - 重载函数的名称必须相同。 ##### 3. 引用： 引用在C++中类似于指针，但它更安全且使用更方便。引用在声明时必须被...
C++ Primer 第四版学习笔记.rar
12-05
《C++ Primer 第四版学习笔记》是一份深入学习C++编程语言的宝贵资源，它由一位经验丰富的学习者在2014年整理而成，旨在帮助初学者更有效地掌握C++的基础和进阶概念。这份笔记以清晰、实用的方式阐述了C++ Primer第...
Essential C++学习记录&笔记整理30（重载iostream运算符）
Bqv它不想做功的博客
05-11 824
这一节解决了我前面遇到的操作符重载的问题而不能显示类对象的数据，以及输出的显示顺序问题。 好的让我们开始总结这一节所学 为什么有要重载iostream运算符？ 因为我们想对某个类对象进行读写操作。不重载iostream类运算符直接cout<<类对象<<endl;或cin>>类对象;编译器会报错 目录重载ostream运算符重载istream运算符报错信息，学习一下 重载ostream运算符 直接cout<<类对象<<endl;编译器会报错，所以
常用的c++特性--＞day02
m0_69093426的博客
11-06 663
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1714
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
STL之vecor的使用(超详解)
最新发布
2302_80220709的博客
11-11 491
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
【Effective C++】阅读笔记5
gma999的博客
11-07 904
Effective C++ 面向对象和模板相关章节
扫雷游戏代码分享(c基础)
lb3636363636的博客
11-11 183
创建两个.c 一个.h。
【C++】AVL树的了解和简单实现
2301_81577798的博客
11-11 388
AVL树的简单实现
C++学习笔记：运算符重载深入解析
"运算符重载简介(cont)-C++学习笔记" 在C++中，运算符重载是一项重要的特性，允许开发者根据需要为不同的数据类型定制运算符的行为。运算符重载并不意味着创建全新的运算符，而是对已存在的运算符进行重新定义，使...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值