更多的重载

最新推荐文章于 2024-10-04 17:07:53 发布
最新推荐文章于 2024-10-04 17:07:53 发布
阅读量81 收藏
点赞数
分类专栏： C++语法基础 文章标签： c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liyiran_/article/details/129782271
版权

更多的重载

  • 重载类型转换

  • 重载内存分配释放

  • 重载递增递减

重载类型转换

实现类型转变运算符

  • 类型转换运算符只能重载为类的成员函数

  • 类型转换运算符没有返回值,他的返回值由类型转换的类型来决定

  • 语法:operator 类型()const

hstring::operator int()
{
	int val{ 0 };

	//int i 标尺
	//cstr[0]='-',i=1;   cstr[0]!='-',i=0
	int i = cstr[0] == '-';

	while (cstr[i] >= '0' && cstr[i] <= '9')
	{
		val = val * 10 + cstr[i++] - 48;
	}

	//val=val*((表达式)*2-1)，在有负号时表达式为0，无负号时表达式为1
	val = val * ((cstr[0] != '-') * 2 - 1); 

	return val;
}

int main()
{
	hstring str{ "123" };
	str = str + 456;
	int x = (int)str;
	std::cout << x;//123456
}

解决隐式类型转换带来的多义性问题

在类型转换重载函数前加 explicit关键字可以限制该函数禁止使用隐式类型转换(C++ 11)

（但可以强制类型转换）

explicit operator int();

  • 问题背景

class T
{
public:
    T(int val)
    {}

    operator int(){
        return 1;
    }

    int operator+(T x){
        return 2;
    }
};

int main()
{
    T t1{ 100 }, t2{ 200 };
    int x = t1 + 100;//报错
    //有歧义，t1可以隐式类型转换为int，x=101
    //也可以是100类型转换为T，x=102
}

  • 使用explicit

class T
{
public:
    T(int val)
    {}

    explicit operator int()//explicit
	{
        return 1;
    }

    int operator+(T x){
        return 2;
    }
};

int main()
{
    T t1{ 100 }, t2{ 200 };
    int x = t1 + 100;
    //不允许t1隐式类型转换成int，所以100转换成T类
    std::cout<<x;//2

    int y=(int)t1+100;//可以强制类型转换
    std::cout<<t1;//1
}
explicit operator int()
{...}


hstring str{-123};

int x=str+123;//报错
//因为 str+123 是hstring类型的,而operator int()被explicit修饰,即hstring不能隐式类型转换为int

int x=(int)(str+123);//可以强制类型转换
std::cout<<x;//-123123

int x=(int)(str)+123;//-123+123=0
std::cout<<x;//0

bool类型与void*的选择

某些时候,我们为了表示某个类里的指针是否为空,可以重载该类的void*类型来实现如下操作

if(p)

if(!p)

if(p!=NULL)

if(p!=nullptr)

但是其实也可以实现重载bool类型转换来实现该操作,但是我们一般不推荐重载bool类型

hstring::operator void* ()
{
	return cstr;
}

int main()
{
	hstring str{ 123 };
	if (str == nullptr)std::cout << "空字符串";
	else std::cout << "非空字符串";
}

重载内存分配释放

new和delete的工作原理

new的工作原理

Role*user=new Role();

  1. 通过new分配内存空间 （能接管）

  1. 调用构造函数

  1. 返回指针

delete user;

  1. 调用析构函数

  1. 通过delete释放内存 （能接管）

重载内存分配

内存分配在C++中是比较重要的内容，有的时候我们需要重载内存分配和释放，大部分时候是为了解决内存碎片的问题，

  • new的六种形式

//new的六种形式:
void* operator new (size_t size);//size_t就是unsigned，size代表你要分配的内存的大小
void* operator new[](size_t size);
void* operator new(size_t size,const std:nothrow_t&) noexcept;
void* operator new[](size_t size,const std:nothrow_t&) noexcept;
//禁止重载的两种形式
void* operator new(size__t size,void* p) noexcept;//可以指定内存分配到这块区域
void* operator new[](size_t size,void* p) noexcept;

blut shota = new ((void*)0x20000) bult[10];

char* mem=new char[0x1000];

int main()
{
    blut* shota = new (mem) blut[10];

	std::cout<<(void*)mem<<std::endl;//0175A578
    std::cout<<shota<<std::endl;//0175A578

    delete[] (mem);
}
void* blut::operator new(size_t size)
{
    return new blut;//死循环，因为new blut继续调用void* operator new(size_t size)
}
——————————————————————————————————————————————————————————————————————————————————————————
void* blut::operator new(size_t size)
{
    return ::operator new (size);//加上全局符号，调用的是默认的那个new
}

重载内存释放

内存分配在C++中是比较重要的内容，有的时候我们需要重载内存分配和释放，大部分时候是为了解决内存碎片的问题，

delete的六种形式:

void operator delete (void* adr) noexcept;
void operator delete[](void* adr) noexcept;
void operator delete(void* adr,const std:nothrow_t&) noexcept;
void operator delete[](void* adr,const std:nothrow_t&)noexcept;
void operator delete(void* adr,void* p) noexcept;
void operator delete[](void+ adr,void* p) noexcept;
class blut
{
public:
    float x;
    float h;
    float y;
    float damage;

    void* operator new(size_t size);
    void operator delete(void* adr) noexcept;
};

/*
void* blut::operator new(size_t size)
{
    return new blut;//死循环
}
*/

char* mem = new char[0x10000];

void* blut::operator new(size_t size)
{
    return mem;
}

void blut::operator delete(void* adr) noexcept
{

}


int main()
{
    blut* shota = new blut;

    shota->x = 100;

    delete shota;
}

小细节

  1. void* blut::operator new(size_t size)其实是static类型，所以没有this指针

因为new的时候还在分配内存空间，没有自己的内存空间也就没有this指针

  1. void blut::operator delete(void* adr) noexcept也是static类型，也没有this指针

因为在使用delete之前已经调用析构函数，内存空间已经释放

删除不想用的new和delete版本

删除系统默认函数

class blut
{
public:
    float x;
    float h;
    float y;
    float damage;

    void* operator new(size_t size);
    void operator delete(void* adr) noexcept;

    void* operator new[](size_t size) = delete;//删除
    void operator delete[](void* adr) = delete;//删除
};

重载带有额外参数的new和delete

为了方便和提高灵活性,可以重载带有额外参数的new和delete版本

void* operator new(size_t size.const char* meminfo);
void*operator delete(void*adr,const char* meminfo) noexcept;

但是带有额外参数的delete版本不能手动调用, 只有在构造函数发生异常的时候, 系统会自动调用

void* blut::operator new(size_t size,const char* txt)
{
    std::cout << txt;
    return mem;
}
//要写相对应的delete版本
void blut::operator delete(void* adr, const char* txt) noexcept
{

}

int main()
{
    blut* shota = new ("test") blut;

    delete () shota;//报错，所以还要准备一个普通版本的delete
}
————————————————————————————————————————————————————————————————————————————————————————
void* blut::operator new(size_t size,const char* txt)
{...}
void blut::operator delete(void* adr, const char* txt) noexcept
{...}

void blut::operator delete(void* adr) noexcept//普通版本的delete
{...}

int main()
{
    blut* shota = new ("test") blut;
    delete shota;
}
class blut
{
    bool bUse = true;
public:
    float x;
    float h;
    float y;
    float damage;

    ~blut();
    void* operator new(size_t size,const char* txt);
    void operator delete(void* adr, const char* txt) noexcept;
    void operator delete(void* adr) noexcept;
    void* operator new[](size_t size) = delete;
    void operator delete[](void* adr) = delete;
};


char* mem = new char[1000 * sizeof(blut)]{};//记得将内存初始化为0

void* blut::operator new(size_t size,const char* txt)
{
    blut* dat = (blut*)mem;
    for (int i = 0; i < 1000; i++)
    {
        if (!dat[i].bUse)return &dat[i];
    }
}

void blut::operator delete(void* adr, const char* txt) noexcept
{

}

void blut::operator delete(void* adr) noexcept
{
    //static类型的函数，不能将bUse设置成false
    //在析构函数里设置
    //delete函数的工作原理：先调用析构函数，然后使用delete释放内存
}

blut::~blut()
{
    bUse = false;
}


int main()
{
    blut* shota1 = new ("test") blut;
    blut* shota2 = new ("test") blut;
    blut* shota3 = new ("test") blut;
    delete shota1;
    blut* shota4 = new ("test") blut;//放在shota1的内存里
    delete shota2;
    blut* shota5 = new ("test") blut;//放在shota2的内存里

    std::cout << shota1 << std::endl;//010AECA0
    std::cout << shota2 << std::endl;//010AECB4
    std::cout << shota3 << std::endl;//010AECC8
    std::cout << shota4 << std::endl;//010AECA0
    std::cout << shota5 << std::endl;//010AECB4
}

重置递增递减运算符

重载前置++/--

前置++/--可以重载为类的方法或者是全局函数

方法:

返回类型 operator++();

返回类型 operator--();

全局函数

返回类型 operator++(操作数类型 操作数);

返回类型 operator--(操作数类型 操作数)

class hint
{
	char* mem[4];
public:
	hint(int val=0);
	~hint();
	operator int();
	void operator=(int val);
	hint& operator++();//前置++  （类的方法）

};
hint& operator--(hint& val);//前置--  （全局函数）

hint& hint::operator++()//前置++，先+1后进行运算 
{
	*this = *this + 1;
	return *this;
}

hint& operator--(hint& val)//前置--（全局函数）
{
	val = val - 1;
	return val;
}

后置+/--

后置++/--可以重载为类的方法或者是全局函数

方法:

返回类型 operator++(int); //int参数没有意义，就是用来区分前置++和后置++

返回类型 operator--(int);

全局函数

返回类型 operator++(操作数类型 操作数, int);

返回类型 operator--(操作数类型 操作数, int);

hint& hint::operator++(int)
{
	hint val = *this;

	*this = *this + 1;
	return val;
}
/*使用时报错
因为hint val=*this;会调用编译器默认的构造函数hint(hint& val);
于是构造函数进行纯粹的复制
	mem[0] = new char;
	mem[1] = new char;
	mem[2] = new char;
	mem[3] = new char;
而函数结束时val调用析构函数
hint::~hint()
{
	delete mem[0];
	delete mem[1];
	delete mem[2];
	delete mem[3];
}
指针被释放，再使用时就会报错
*/
————————————————————————————————————————————————————————————————————————————————————————
hint& hint::operator++(int)
{
	hint val = (this)*this;//调用hint (int val)构造函数
	*this = *this + 1;
	return val;
}

/*仍然出错
比如说a++
return val的之后a=val,会调用hint (hint& val),同样直接复制地址
而函数删除的时候调用析构函数，同上，内存被释放
a使用的时候就会报错
*/
————————————————————————————————————————————————————————————————————————————————————————
//解决方法：自己写一个hint (hint& val)
hint::hint(hint& val) :hint((int)val)
//委托hint(int val)构造，需要将该构造函数hint类型的val转换成int类型
{}
Yuruiuu
关注
专栏目录
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++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
C++重温笔记(六): 运算符重载
Miracle8070
10-18 1382
1. 写在前面 c++在线编译工具，可快速进行实验: https://www.bejson.com/runcode/cpp920/ 这段时间打算重新把c++捡起来， 实习给我的一个体会就是算法工程师是去解决实际问题的，所以呢，不能被算法或者工程局限住，应时刻提高解决问题的能力，在这个过程中，我发现cpp很重要， 正好这段时间也在接触些c++开发相关的任务，所有想借这个机会把c++重新学习一遍。 在推荐领域， 目前我接触到的算法模型方面主要是基于Python， 而线上的服务全是c++(算法侧， 业务那边基本上
C++语法——详解运算符重载
热门推荐
weixin_61857742的博客
07-28 3万+
运算符重载是C++的一个重要特性。有了运算符重载，在代码编写时能更好的实现封装。 一.运算符重载介绍 运算符重载，就是让原本已经存在的运算符有了新的用法和意义。 比如我们熟知的减号（-），原本是用来进行数字的相减处理。但经过运算符重载后，它可以用来进行其他类型的相减，像时间相减、日期相减、字符相减等等。只要是你能想到的，通过运算符重载基本都能够实现。 对于C++而言，运算符重载一般是作为类的成员函数出现。因为当我们需要运算符重载时，往往是类中一种特殊的类型需要处理或者类本身需要处理。就像我们可能会把.
C++运算符重载总结
qq_43148810的博客
10-31 3915
@著作权归作者所有：来自CSDN博客作者大胡子的艾娃的原创作品，如需转载，请注明出处https://blog.csdn.net/qq_43148810，否则将追究法律责任。 如有错误的地方欢迎指正，谢谢! 更多内容请关注个人博客：https://blog.csdn.net/qq_43148810 ...
C++继承和重载
此心光明，亦复何言~
04-12 6260
C++继承和重载 c++集成 继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个...
重载函数
仰望星空
11-05 1136
一、背景 出现在相同作用域中的两个函数，如果具有相同的名字而形参表不同，则成为重载函数。通过省去为函数起名并且记住函数名字的麻烦，函数重载简化了程序的实现，使程序更容易理解。具体的工作是由编译器完成。 1.1 隐藏 重载与作用域是分不开的两个概念，脱离了作用域谈论重载是毫无意义的。如果局部地声明一个函数，那么该函数将屏蔽而不是重载在外层作用域中声明的同名函数——正所谓“强龙压不过地头蛇”。良...
⚡【C++要笑着学】(8) 重载：运算符重载 | 赋值重载 (默认) | const 成员 | const 修饰成员函数 | 取地址重载 (默认) | const 取地址重载 (默认)
有道无术, 术尚可求。有术无道, 止于术。
03-20 5889
本章将开始讲解运算符重载。运算符重载的技能是学习实现STL 内部底层的不可缺少的 "利器" ！所以本篇非常重要，下一篇会手把手实现一个Date类，可以进一步地实战体会运算符重载。
Java 重载与覆盖
假装你是大灰狼的专栏
11-20 969
1. 重载与覆盖 重载，提供多个具有相同名字的方法，但是它们具有可以彼此分开的不同签名。 覆盖，将方法的超类实现替代为自己的实现，签名必须相同。 如果返回的类型是引用类型，那么覆盖方法的返回类型可以申明为超类方法返回类型的值类型。 子类可以改变超类方法的访问修饰符，但只能提供更多的访问权限。 覆盖方法可以改变其他的方法修饰符，可以改变synchronized、native和strictfp修饰...
关于函数重载
persue_8168的博客
09-20 1982
一.构成函数重载的条件如下： 1.函数名相同。 2.这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同，即参数列表不同。 3.返回值类型不同不构成重载函数。 二.重载函数的匹配原则： 1、严格匹配，找到后就调用。 2、没有找到严格匹配的函数，但是可以通过隐式转化，找到适合的重载函数。 例： 1.参数类型不一样 void print(int a) { pr
实验7 多态性和运算符重载.doc
12-20
"实验7 多态性和运算符重载" 多态性是指类族中具有相似功能的不同函数使用同一名称来实现，从而可以使用相同的调用方式...通过实验，我们将更好地理解多态性和运算符重载的概念，并掌握如何在实际编程中应用这些技术。
内核重载_hospitalb3n_内核重载_x86内核重载_
09-30
总之，x86内核重载是一项复杂但富有挑战性的任务，涉及到操作系统原理、编程技术和系统架构等多个方面。通过定制内核，我们可以提升系统的性能，增强安全性，或者实现独特的功能，这对于系统管理员、开发者和研究者...
WCF重载demo
02-21
当我们谈论服务重载时，我们是指在同一接口下定义多个同名但参数列表不同的操作。 在提供的“WCF实现重载demo”压缩包中，可能包含两个示例，分别展示了两种方法来实现WCF服务的重载： 1. **方法一：使用不同数量...
java 函数的重载和重写实例代码
09-01
在Java中，函数的重载（Overloading）和重写（Overriding）是多态性的重要表现形式，它们都是实现面向对象设计原则的关键手段。 1. 重载（Overloading）： 重载发生在同一个类中，它允许我们创建多个同名的方法，...
详解JS函数重载
10-25
需要注意的是，arguments对象的使用也存在争议，比如在严格模式下一些行为会有所不同，且ECMAScript 6引入的剩余参数（rest parameters）和默认参数等新特性，提供了一种更符合函数重载理念的参数处理方法，这进一步...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1686
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 307
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
C++：图的最短路径问题
最新发布
han2205277149的博客
10-04 646
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
C++的类型转换
2401_83427936的博客
09-27 1725
在自定义类型中重载string，这里涉及到文件的写入，string的str转c_str,弄成char类型才能插入直接重载int和bool的，就支持A转int值和bool了。这里加explcit不影响转换，更支持了与其他的相反，不加explcit，A不能转double，只能转int，加了就可以了。放宽了标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用。
C++中的运算符重载与多态性
课程首先介绍了多态性的概念，包括多态的分类，如参数多态、包含多态（通过虚函数实现）、重载多态和强制多态，并区分了通用多态和专用多态。接着，详细阐述了多态的实现机制，包括编译时的多态（静态联编）和运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值