【第四天]C++高级类和对象：运算符重载、string类和智能指针的深度解析

已于 2023-10-26 10:03:05 修改
阅读量689 收藏 24
点赞数 25
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2023-10-24 20:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75045191/article/details/132204323
版权

 

目录

一、运算符重载 

1、可以重载的运算符

2、重载<<运算符（全局函数实现） 

3、重载输入>>运算符 

 4、重载加法运算符+（全局函数实现）

5、重载加法运算符+（成员函数实现 推荐）

6、重载==运算符（成员函数实现 ）

7、重载++运算符

（1）重载后置++

（2）重载前置++

8、重载函数调用运算符()

二、string类

三、智能指针

一、运算符重载 

        运算符重载 是对已有的运算符 指定新功能，不能创建新运算符。

运算符重载关键字operator

语法：operator@        （@表示被重载的运算符）

思路：

1、弄懂 函数的参数中参数个数取决于运算符是一元还是二元。

2、弄懂运算符左边的运算对象 是类的对象 还是其他.

        类的对象：全局函数实现（一元是一个参数，二元是两个参数）

                          成员函数实现（一元没有参数，二元是一个参数）--推荐

        其他：只能是全局函数实现 

1、可以重载的运算符

2、重载<<运算符（全局函数实现） 

3、重载输入>>运算符 

 4、重载加法运算符+（全局函数实现）

#include<iostream>
#include<string>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& out, Person ob);
	friend istream& operator>>(istream &in, Person &ob);
	friend Person operator+(Person ob1, Person ob2);
private:
	int num;
	string name;
	float score;
public:
	Person() {}
	Person(int num, string name, float score) :num(num), name(name), score(score) {}//初始化列表
};
ostream& operator<<(ostream& out, Person ob)
{
	out << ob.num << " " << ob.name << " " << ob.score << endl;
	return out;
}
istream& operator>>(istream &in, Person &ob)
{
	in >> ob.num >> ob.name >> ob.score;
	return in;
}
Person operator+(Person ob1, Person ob2)
{
	Person tmp;
	tmp.num = ob1.num + ob2.num;
	tmp.name = ob1.name + ob2.name;
	tmp.score = ob1.score + ob2.score;
	return tmp;
}
int main(int argc, char* argv[])
{
	Person lucy(100, "lucy", 85.5f);
	Person bob(101, "bob", 95.5f);
	Person tom(102, "tom", 75.5f);
	cout << lucy + bob + tom << endl;
	return 0;
}

5、重载加法运算符+（成员函数实现 推荐）

#include<iostream>
#include<string>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& out, Person ob);
	friend istream& operator>>(istream &in, Person &ob);
private:
	int num;
	string name;
	float score;
public:
	Person() {}
	Person(int num, string name, float score) :num(num), name(name), score(score) {}//初始化列表
	//成员函数重载+
	Person operator+(Person ob)
	{
		Person tmp;
		tmp.num = this-> num + ob.num;
		tmp.name = this-> name + ob.name;
		tmp.score = this-> score + ob.score;
		return tmp;
	}
};
ostream& operator<<(ostream& out, Person ob)
{
	out << ob.num << " " << ob.name << " " << ob.score << endl;
	return out;
}
istream& operator>>(istream &in, Person &ob)
{
	in >> ob.num >> ob.name >> ob.score;
	return in;
}	
int main(int argc, char* argv[])
{
	Person lucy(100, "lucy", 85.5f);
	Person bob(101, "bob", 95.5f);
	Person tom(102, "tom", 75.5f);
	cout << lucy + bob + tom << endl;
	return 0;
}

6、重载==运算符（成员函数实现 ）

#include<iostream>
#include<string>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& out, Person ob);
	friend istream& operator>>(istream &in, Person &ob);
private:
	int num;
	string name;
	float score;
public:
	Person() {}
	Person(int num, string name, float score) :num(num), name(name), score(score) {}//初始化列表
	//成员函数重载==
	bool operator==(Person& ob)
	{
		if (num == ob.num && name == ob.name && score == ob.score)
			return true;
		return false;
	}
};
ostream& operator<<(ostream& out, Person ob)
{
	out << ob.num << " " << ob.name << " " << ob.score << endl;
	return out;
}
istream& operator>>(istream &in, Person &ob)
{
	in >> ob.num >> ob.name >> ob.score;
	return in;
}	
int main(int argc, char* argv[])
{
	Person lucy(100, "lucy", 85.5f);
	Person bob(101, "bob", 95.5f);
	if (lucy == bob)
	{
		cout << "相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
	return 0;
}

7、重载++运算符

（1）重载后置++

++a(前置++)，它就调用operator++(a)

a++（后置++），它就会去调用operator++(a,int)//int为占位参数。

#include<iostream>
#include<string>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& out, Person ob);
	friend istream& operator>>(istream &in, Person &ob);
private:
	int num;
	string name;
	float score;
public:
	Person() {}
	Person(int num, string name, float score) :num(num), name(name), score(score) {}//初始化列表
	//重载后置++ 普通全局函数为operator++(a,int)
    //成员函数
	Person operator++(int)
	{
		//先保存 旧的值
		Person old = *this;//*this == lucy
		//lucy++自增
		this-> num = this-> num + 1;
		this-> name = this-> name + this-> name;//（自定义操作）
		this-> score = this-> score + 1;
		return old;//返回旧值
	}
};
ostream& operator<<(ostream& out, Person ob)
{
	out << ob.num << " " << ob.name << " " << ob.score << endl;
	return out;
}
istream& operator>>(istream &in, Person &ob)
{
	in >> ob.num >> ob.name >> ob.score;
	return in;
}	
int main(int argc, char* argv[])
{
	Person lucy(100, "lucy", 85.5f);
	Person bob;
	//先使用 后++
	bob = lucy++;
	cout << bob << endl;
	cout << lucy << endl;
	return 0;
}

（2）重载前置++

#include<iostream>
#include<string>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& out, Person ob);
	friend istream& operator>>(istream &in, Person &ob);
private:
	int num;
	string name;
	float score;
public:
	Person() {}
	Person(int num, string name, float score) :num(num), name(name), score(score) {}//初始化列表
	//重载后置++ 普通全局函数为operator++(a,int)
    //成员函数
	Person operator++(int)
	{
		//先保存 旧的值
		Person old = *this;//*this == lucy
		//lucy++自增
		this-> num = this-> num + 1;
		this-> name = this-> name + this-> name;//（自定义操作）
		this-> score = this-> score + 1;
		return old;//返回旧值
	}
	//重载前置++ 普通全局函数为operator++(a)
    //成员函数
	Person operator++(int)
	{
		//先++
		this-> num = this-> num + 1;
		this-> name = this-> name + this-> name;//（自定义操作）
		this-> score = this-> score + 1;
        //后使用
		return  *this;
	}
};
ostream& operator<<(ostream& out, Person ob)
{
	out << ob.num << " " << ob.name << " " << ob.score << endl;
	return out;
}
istream& operator>>(istream &in, Person &ob)
{
	in >> ob.num >> ob.name >> ob.score;
	return in;
}	
int main(int argc, char* argv[])
{
	Person lucy(100, "lucy", 85.5f);
	Person bob;
	///先++ 后使用
	bob = ++lucy;
	cout << bob << endl;
	cout << lucy << endl;
	return 0;
}

8、重载函数调用运算符()

        重载（）运算符 一般用于 为算法 提供策略。

二、string类

        string类完成重载输入输出、重载中括号运算符、重载+运算符、重载=赋值运算符（深拷贝）、重载>运算符等运算

mystring.h

#ifndef MYSTRING_H
#define MYSTRING_H
#include <iostream>
using namespace std;
class MyString
{
    friend ostream& operator<<(ostream &out, MyString ob);
    friend istream& operator>>(istream &in, MyString &ob);
private:
    char *str;
    int size;
public:
    MyString();
    MyString(char *str);
    MyString(const MyString &ob);//构造拷贝
    ~MyString();
    int getSize() const;
    //成员函数重载[]
    char& operator[](int pos);
    MyString operator+(MyString ob);
    MyString operator+(char *str);

    MyString& operator=(MyString ob);
    MyString& operator=(char *str);

    bool operator>(MyString ob);
    bool operator>(char *str);

    // bool operator<(MyString ob);
    // bool operator<(char *str);
    // bool operator==(MyString ob);
    // bool operator==(char *str);
    // bool operator!=(MyString ob);
    // bool operator!=(char *str);
};

#endif // MYSTRING_H

mystring.cpp

#include "mystring.h"
#include <string.h>

int MyString::getSize() const
{
    return size;
}

char& MyString::operator[](int pos)
{
    if(pos<0 || pos>=size)
    {
        cout<<"元素位置不合法"<<endl;
        exit(‐1);
    }
    return str[pos];
}

MyString MyString::operator+(MyString ob)
{
    MyString tmp;
    tmp.size = size+ob.size;
    tmp.str = new char[tmp.size+1];
    memset(tmp.str, 0, tmp.size+1);

    strcpy(tmp.str, str);
    strcat(tmp.str, ob.str);

    return tmp;
}

MyString MyString::operator+(char *str)
{
    MyString tmp;
    tmp.size = size+strlen(str);
    tmp.str = new char[tmp.size+1];
    memset(tmp.str, 0, tmp.size+1);

    strcpy(tmp.str, this‐>str);
    strcat(tmp.str, str);

    return tmp;
}

MyString &MyString::operator=(MyString ob)
{
    //str2 = str1;
    if(this‐>str != NULL)
    {
        delete [] this‐>str;
        this‐>str = NULL;
    }
    this‐>size = ob.size;
    this‐>str = new char[this‐>size+1];
    memset(this‐>str, 0, this‐>size+1);
    strcpy(this‐>str, ob.str);

    return *this;
}

MyString &MyString::operator=(char *str)
{
    //str2 = str1;
    if(this‐>str != NULL)
    {
    delete [] this‐>str;
    this‐>str = NULL;
    }

    this‐>size = strlen(str);
    this‐>str = new char[this‐>size+1];
    memset(this‐>str, 0, this‐>size+1);
    strcpy(this‐>str, str);
    
    return *this;
}

bool MyString::operator>(MyString ob)
{
    if(str==NULL || ob.str == NULL)
    {
        exit(‐1);
    }
    if(strcmp(this‐>str, ob.str) > 0)
    {
        return true;
    }
        return false;
    }

bool MyString::operator>(char *str)
{
    if(this‐>str==NULL || str == NULL)
    {
        exit(‐1);
    }
    if(strcmp(this‐>str, str) > 0)
    {
        return true;
    }
    return false;
}

MyString::MyString()
{
    str=NULL;
    size=0;
}

myString::MyString(char *str)
{
    size = strlen(str);
    this‐>str = new char[size+1];
    memset(this‐>str, 0, size+1);
    
    strcpy(this‐>str, str);
}

MyString::MyString(const MyString &ob)
{
    size = ob.size;
    str = new char[size+1];
    memset(str, 0, size+1);
    strcpy(str, ob.str);
}

myString::~MyString()
{
    if(str != NULL)
    {
        delete [] str;
        str=NULL;
    }
}

//全局函数实现 <<重载
ostream& operator<<(ostream &out, MyString ob)
{
    out<<ob.str;
    return out;
}
//全局函数实现 >>重载
istream& operator>>(istream &in, MyString &ob)
{
    char buf[1024]="";
    cin>>buf;

    if(ob.str != NULL)//ob已经有字符串
    {
        delete [] ob.str;
        ob.str = NULL;
    }

    ob.size = strlen(buf);
    ob.str = new char[ob.size+1];
    memset(ob.str, 0,ob.size+1);
    strcpy(ob.str, buf);

    return in;
}

三、智能指针

        智能指针：通过重载* 和->运算符。解决 堆区空间的对象 释放问题

class Data
{
public:
    Data()
    {
        cout<<"无参构造"<<endl;
    }
    ~Data()
    {
        cout<<"析构函数"<<endl;
    }
    void func()
    {
        cout<<"func函数"<<endl;
    }
};
class SmartPointer//智能指针类
{
private:
    Data *p;
public:
    SmartPointer(){}
    SmartPointer(Data *p)
    {
    this‐>p = p;
    }
    ~SmartPointer()
    {
        delete p;
    }
    //重载*和->
    Data& operator*()
    {
        return *p;
    }
    Data* operator‐>()
    {
        return p;
    }
};

void test02()
{
    SmartPointer ob(new Data);
    (*ob).func();//ob.operator *().func();

    ob‐>func();//ob.operator ‐>()‐>func();
}

寒晓星
关注
  • 25
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 26
    评论
专栏目录
C++智能指针：auto-ptr详解.pdf
02-27
C++智能指针：auto_ptr详解 指针，相信⼤家并不陌⽣。⽆论是我们在进⾏查看内存还是在修改字符串，我们都会⽤到指针。 最常见的情况则是我们使⽤malloc或者new申请到了⼀块内存，然后⽤⼀个指针来保存起来。我们都...
C++：运算符重载：以String类为例
Rain的博客
10-26 1668
运算符重载         运算符重载：即定义一个重载运算符的函数,使指定的运算符不仅能实现原有的功能，而且能实现在函数中指定的新的功能。         运算符重载实质上是函数的重载 重载运算符的函数一般格式如下：        函数类型 operator 运算符名称(形参表)...
Jeff学C++头大第四天：运算符重载及智能指针（what？）
Jeff.Ye的博客
10-31 123
一、运算符重载 C++中是运算符当作函数来看待，所以C++中的运算符可以重载，这样可以让类对象支持运算符，对类对象进行定制化操作。 例如：string类就支持很多运算符来代替标准库中的函数。 = strcpy += strlen ==|!=|>=|<= strcmp 二、双目录运算符重载 假如：Test a,b; a+b操作可以调用两种函数 Test的成员函数：a是触发者，b是参数 Test operator+(cosnt Test& b) const {
c++运算符重载，string类重载详解，原理理解
h674174380的博客
08-01 2230
c++运算符重载，string类重载详解，原理理解 　C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。 　　运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函
C++类和对象（五）：运算符重载
NewsomTech
02-10 639
文章目录4.5.1 加号运算符重载4.5.2 左移运算符重载4.5.3 递增运算符重载4.5.4 赋值运算符重载4.5.5 关系运算符重载4.5.6 函数调用运算符重载 运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 4.5.1 加号运算符重载 作用：实现两个自定义数据类型相加的运算 class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m
C++学习5：C++赋值运算符重载和下标运算符重载并自定义string实现
12-05 567
C++赋值运算符重载和下标运算符重载
C++ 运算符重载
热门推荐
qq_27278957的博客
12-26 7万+
前言 本文引用于“C语言中文网”，我整理出来放在博客，方便大家共同学习。所有知识点和代码均已亲测可用，如有疑问，可提出，一起讨论学习。 本章内容： 1. C++运算符重载的概念和原理 2. C++重载=（C++重载赋值运算符） 3. C++深拷贝和浅拷贝（C++深复制和浅复制） 4. C++运算符重载为友元函数 5. C++实现可变长度的动态数组 6. C++重载&lt;&lt;和&gt;...
C++知识点43——解引用运算符和箭头运算符的重载及智能指针类的实现
Master Cui的博客
11-07 844
一、概念、 在自定义行为类似指针的类时，需要重载*和->。C++中的智能指针就重载了这两个运算符。->必须是成员函数，*也应该是成员函数。与内置类型保持一致，这两个函数通常都是const的。以为*和->通常不会也不应该改变对象的状态 *运算符的返回值无硬性规则，但是通常都是一个类型的引用 ->运算符的返回值必须是一个类的指针（或者重载了operator->的类的对象）。因为->的作用就是通过对象的指针获取对象的成员 二、示例 通过实现一个智能指针来熟悉这两.
C++核心编程（四）—— 类和对象(5) ：运算符重载
大彤小忆的博客
04-03 3314
5. 运算符重载5.1 加号运算符重载5.2 左移运算符重载5.3 递增运算符重载5.4 赋值运算符重载5.5 关系运算符重载5.6 函数调用运算符重载 5. 运算符重载   运算符重载的概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。   重载的运算符是带有特殊名称的函数，函数名是由关键字operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。   可重载运算符.
C++快速讲解（六）：运算符重载和lambda表达式
等待着冬天的风的博客
03-22 729
前言：主要介绍了运算符重载和lambda的使用。
C++动态数组类的封装实例
12-26
为了实现一个动态数组类的封装，我们需要考虑几个问题：new/delete的使用、内存分配策略、类的四大函数（构造函数、拷贝构造函数、拷贝赋值运算符、析构函数）、运算符的重载。涉及到的知识点很多，对此本文只做简单...
C++中sting类的简单实现方法
01-20
所以我们是很有必要模拟实现它的，况且在面试的时候模拟实现一个String类也是面试官经常会考的，但是因为外界因素的限制我们是不可能模拟的和库里的string一致的(C++库里的string功能更强大)，所以今天我们只模拟...
利用C++仿照string设计实现自己的字符串类型课程设计实验报告
01-11
1、 仿照标准字符串类string ，设计一个自己的字符串类String。 主要完成以下任务： 1）数据成员是字符指针，可自动适应不同的串长度。 2）串复制，既可使用字符串常量进行复制，也可以使用其他的字符串对象进行复制...
C语言代码和C++代码--指针、多线程、文件读写、套接字
11-14
C++_05.1_多态（运算符重载） C++_06.2多线程（简单的） string、vector 图形设备（例） C++_06_3_多线程和类 C++_07_2模板vector 网络通信_test MFC_线程_test socket 服务端和客户端--网上的例子1 类、多线程、套...
c++父类指针指向子类
最新发布
qq_43700779的博客
05-11 102
父类指针指向子类，调用的函数是谁的
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 84
UE5 C++ 的FString类型取值问题。
初识C语言——第十四天
硬件菜鸟的成长之路
05-07 688
【代码】初识C语言——第十四天。
webassembly入门详解（C++）
啊渊的专栏
05-05 1023
webassembly C++ windows下开发环境搭建。
c++运算符重载实现字符串连接
05-19
在 C++ 中，可以使用运算符重载来实现字符串的连接。具体实现如下： ```cpp #include #include class String { private: char* str; public: String() : str(nullptr) {} String(const char* s) { str = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值