C++特殊类的设计与类型转换

这篇具有很好参考价值的文章主要介绍了C++特殊类的设计与类型转换。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

特殊类的设计

请设计一个类,只能在堆上创建对象

通过new创建的类就是堆上的。
方法一:

#include<iostream>

using namespace std;
class HeapOnly
{
public:
	static HeapOnly* func()//这里如果不用静态就无法创建对象了,也导致这个函数无法被调用
	{
		return new HeapOnly;
	}
private:
	HeapOnly()//防止随意的创建对象
	{}
	HeapOnly(const HeapOnly& a) = delete;//如果不删除拷贝函数创建的对象还是在栈上
};
int main()
{
	HeapOnly* p1 = HeapOnly::func();
	//HeapOnly p2(*p1);//这样避免了p2对象创建在栈上
	return 0;
}

这里主要以封禁构造函数为主,让外部只能通过调用func函数方式去创建对象,func函数的内部是通过new创建的,这里要注意的就是拷贝构造的问题。
赋值重载不用删除,因为需要现有一个对象才能赋值给另一个对象,上面的代码只会创建出堆上的对象。
方法二:

#include<iostream>

using namespace std;

class HeapOnly
{
public:
	HeapOnly()
	{}
	void Delete()
	{
		this->~HeapOnly();
	}
private:
	~HeapOnly()
	{}
	HeapOnly(const HeapOnly& a) = delete;
};

int main()
{
	HeapOnly* p1 = new HeapOnly;
	p1->Delete();
	return 0;
}

封禁析构函数,需要自己手动释放内存。

请设计一个类,只能在栈上创建对象

这里要注意一点,静态区也不行。
方法一:

#include <iostream>
using namespace std;
class NonInherit
{
public:
	static NonInherit func()
	{
		return NonInherit();
	}
	void Pintf()
	{
		cout << "Pintf" << endl;
	}
private:
	NonInherit()
	{}
	NonInherit(const NonInherit& p) = delete;
};
int main()
{
	NonInherit::func().Pintf();
	//static NonInherit p1 = NonInherit::func();//防止p1创建在静态区上
	return 0;
}

这里就像匿名对象的感觉,如果不封拷贝构造就会出现注释上的问题。
方法二:

#include <iostream>
using namespace std;
class NonInherit
{
public:
	static NonInherit func()
	{
		return NonInherit();
	}
	void Pintf() const
	{
		cout << "Pintf" << endl;
	}
private:
	NonInherit()
	{}
	NonInherit(const NonInherit& p) = delete;
};
int main()
{
	const NonInherit& p1 = NonInherit::func();//用引用接收
	p1.Pintf();//然后在使用
	return 0;
}

请设计一个类,只能创建一个对象(单例模式)

设计模式:
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
单例模式:

一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。

单例模式有两种实现模式:
饿汉模式
就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。

#include<iostream>
#include<map>
#include<string>
using namespace std;
class Singleton
{
public:
	static Singleton& func()
	{
		return _a;//拿到对象本身
	}
	void Insert(string str, int salary)
	{
		arr[str] = salary;
	}
	void Printf()
	{
		for (auto& e : arr)
		{
			cout << e.first << ":" << e.second << endl;
		}
	}
private:
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	map<string, int> arr;
	static Singleton _a;
};
Singleton Singleton::_a;//在外部初始化对象,同类对象只会调用一次构造函数

int main()
{
	Singleton::func().Insert("aaa", 111);
	Singleton&p = Singleton::func();
	p.Insert("bbb", 222);
	p.Insert("ccc", 333);
	p.Insert("ddd", 444);
	p.Insert("eee", 555);
	p.Printf();
	return 0;
}

C++特殊类的设计与类型转换
这个模式缺点:
如果数据量太大,启动就会非常的缓慢。
如果有多个文件一起,都有饿汉模式的代码,他们互相之间有依赖,但是编译器很难控制先初始化谁。

懒汉模式
如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。

#include<iostream>
#include<map>
#include<string>
#include<mutex>
using namespace std;
template<class T>
class Lock
{
public:
	Lock(T& p)//因为锁不允许拷贝
		:_p(p)
	{
		_p.lock();
	}
	~Lock()
	{
		_p.unlock();
	}
private:
	T& _p;//所以这里成员用引用
};
class Singleton
{
public:
	static Singleton& func()
	{
		if (_a == nullptr)//避免每次调用的时候都进行加锁的操作,提高效率
		{
			Lock<mutex> p(mex);//用智能指针是为了防止下面的new出现异常导致未解锁
			//如果不加锁,容易发生内存泄露,开辟多个空间,最终指针只会指向一处空间
			if (_a == nullptr)//第一次调用创建对象
			{
				_a = new Singleton;
			}
		}
		return *_a;
	}
	void Insert(string str, int salary)
	{
		arr[str] = salary;
	}
	void Printf()
	{
		for (auto& e : arr)
		{
			cout << e.first << ":" << e.second << endl;
		}
	}
private:
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	map<string, int> arr;
	static Singleton* _a;
	static mutex mex;//锁
};
Singleton* Singleton::_a = nullptr;//在外部初始化对象,同类对象只会调用一次构造函数
mutex Singleton::mex;//定义锁
int main()
{
	Singleton::func().Insert("aaa", 111);
	Singleton& p = Singleton::func();
	p.Insert("bbb", 222);
	p.Insert("ccc", 333);
	p.Insert("ddd", 444);
	p.Insert("eee", 555);
	p.Printf();
	return 0;
}

C++特殊类的设计与类型转换
并且,一般单例对象不用考虑释放,因为一个进程在结束的时候资源会回收给OS。
如果有需要处理的资源,需要在内部定义一个函数去处理某个资源,然后其他资源不用处理:

static void Delete()//手动释放资源
{
	Lock<mutex> p(mex);
	if (_a != nullptr)
	{
		delete _a;
		_a = nullptr;
	}
}

假如忘记回收这个资源了呢?
在内部定义一个GC的类,这个类的析构函数内部调用上面的Delete函数。

class GC
{
public:
	~GC()
	{
		if (_a)
		{
			cout << "~GC()" << endl;
			Delete();
		}
	}
};

然后再外部定义一个全局的GC类的对象,在程序结束的时候就会去调用析构函数。
C++特殊类的设计与类型转换
主要是帮助检查有没有手动释放掉这一出资源。
注意:C++11前是无法保证线程静态的初始化是安全的,C++11之后可以。
也就是说懒汉还有这种写法:

static Singleton& func()
{
	static Singleton _a;
	return _a;
}

函数的成员也就不用了静态对象。

C++的类型转换

C语言有两种类型转换,一个是隐式类型转换,另一个是强制类型转换。

#include<iostream>
using namespace std;

int main()
{
	//隐式类型
	int a = 1;
	double b = a;
	//强制类型
	int c = 10;
	int* p = &c;
	int d = (int)p;
	return 0;
}

C++有四种类型转换,是期望大家能够规范使用的。
为什么C++需要四种类型转换
C风格的转换格式很简单,但是有不少缺点的:

1.隐式类型转化有些情况下可能会出问题:比如数据精度丢失。
2.显式类型转换将所有情况混合在一起,代码不够清晰。
因此C++提出了自己的类型转化风格,注意因为C++要兼容C语言,所以C++中还可以使用C语言的转化风格。

static_cast
static_cast用于非多态类型的转换(静态转换),编译器隐式执行的任何类型转换都可用。
static_cast,但它不能用于两个不相关的类型进行转换。
C++特殊类的设计与类型转换
reinterpret_cast
reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释,用于将一种类型转换
为另一种不同的类型。
C++特殊类的设计与类型转换
const_cast
const_cast最常用的用途就是删除变量的const属性,方便赋值。
C++特殊类的设计与类型转换
这里看起来并没有被赋值成功是因为编译器进行了优化,认为const的变量不会被修改,所以这个值一直放在了寄存器中,并没有从内存中获取,数据一直未被更新到寄存器当中。
C++特殊类的设计与类型转换
dynamic_cast
dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型:子类对象指针/引用->父类指针/引用(不需要转换,赋值兼容规则)
向下转型:父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意:

1.dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回0

#include<iostream>
using namespace std;
class A
{
public:
	virtual void f() {}
	int a;
};
class B : public A
{
public:
	int b;
};
void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回
	B* pb = dynamic_cast<B*>(pa);//子类指向父类,访问父类的内容的时候虚表可能会越界产生报错
	if (pb)//检查是否合法,其实就是拒绝了子类指向父类
	{
		pb->a++;
		pb->b++;
		cout << "a++ " << "b++" << endl;
	}
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}

C++特殊类的设计与类型转换
注意:
强制类型转换关闭或挂起了正常的类型检查,每次使用强制类型转换前,程序员应该仔细考虑是
否还有其他不同的方法达到同一目的,如果非强制类型转换不可,则应限制强制转换值的作用
域,以减少发生错误的机会。强烈建议:避免使用强制类型转换。文章来源地址https://www.toymoban.com/news/detail-480371.html

到了这里,关于C++特殊类的设计与类型转换的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++】特殊类设计+单例模式+类型转换

    需要云服务器等云产品来学习Linux的同学可以移步/--腾讯云--/--阿里云--/--华为云--/官网,轻量型云服务器低至112元/年,新用户首次下单享超低折扣。   目录 一、设计一个类,不能被拷贝 1、C++98 2、C++11 二、设计一个类,只能在堆上创建对象 1、将构造设为私有 2、将析构设为

    2024年02月06日
    浏览(53)
  • 【C++】特殊类设计+类型转换+IO流

    🌇个人主页:平凡的小苏 📚学习格言:命运给你一个低的起点,是想看你精彩的翻盘,而不是让你自甘堕落,脚下的路虽然难走,但我还能走,比起向阳而生,我更想尝试逆风翻盘 。 🛸 C++专栏 : C++内功修炼基地 家人们更新不易,你们的👍点赞👍和⭐关注⭐真的对我真

    2024年02月05日
    浏览(44)
  • c++学习之特殊类设计与类型转换

    方法:c++98,通过私有且只申明不实现拷贝构造与赋值函数,从而实现该类不能被拷贝。c++11引入delete后,可以使构造构造与赋值函数等于delete。效果也是无法被拷贝。 方法一,析构私有化 方法二,构造私有化 方法一: 还是构造私有化,但是注意拷贝构造,我们拷贝

    2024年01月20日
    浏览(44)
  • 从C语言到C++_37(特殊类设计和C++类型转换)单例模式

    目录 1. 特殊类设计 1.1 不能被拷贝的类 1.2 只能在堆上创建的类 1.3 只能在栈上创建的类 1.4 不能被继承的类 1.5 只能创建一个对象的类(单例模式)(重点) 1.5.1 饿汉模式 1.5.2 懒汉模式 2. 类型转换 2.1 static_cast 2.2 reinterpret_cast 2.3 const_cast 2.4 dynamic_cast 3. RTTI(了解)和类型转换常见面

    2024年02月10日
    浏览(48)
  • 【C++】特殊类的设计

    💕 C++98方式: 在C++11之前,想要一个一个类不被拷贝,只有将 拷贝构造函数 定义为私有,这样在类外就不能调用拷贝构造函数来构造对象了。但是在类内还是可以调用拷贝构造函数来构造对象。 所以正确的做法是 将拷贝构造函数定义为私有,同时拷贝构造函数只声明,不

    2024年02月07日
    浏览(42)
  • C++进阶 特殊类的设计

    本篇博客介绍:介绍几种特殊的类 我们的拷贝只会发生在两个场景当中 拷贝构造函数 赋值运算符重载 所以说我们只需要让类失去 或者说不能使用这两个函数即可 这里有两个解决方案 在C++98中 我们将拷贝构造函数只声明不定义 并且将其访问权限设置为私有即可 原因如下

    2024年02月12日
    浏览(40)
  • C++之特殊类的设计

    目录 一、单例模式 1、设计模式 2、单例模式 1、饿汉模式 2、懒汉模式 3、单例对象的释放问题 二、设计一个不能被拷贝的类 三、设计一个只能在堆上创建对象的类 四、设计一个只能在栈上创建对象的类 五、设计一个不能被继承的类 概念: 设计模式(Design Pattern)是一套被

    2024年02月08日
    浏览(44)
  • 【C++高阶(八)】单例模式&特殊类的设计

    💓博主CSDN主页:杭电码农-NEO💓   ⏩专栏分类:C++从入门到精通⏪   🚚代码仓库:NEO的学习日记🚚   🌹关注我🫵带你学习C++   🔝🔝 在实际场景中,总会遇见一些特殊情况, 比如设计一个类,只能在堆上开辟空间, 亦或者是设计一个类只能实例化一个对象 在实际需求的场景

    2024年02月04日
    浏览(47)
  • 【C++】异常+智能指针+特殊类和类型转换

    上天可能觉得我太孤独,派你来和我一起对抗虚无。 1. C语言传统处理错误的方式无非就是返回错误码或者直接是终止运行的程序。例如通过assert来断言,但assert会直接终止程序,用户对于这样的处理方式是难以接受的,比如用户误操作了一下,那app直接就终止退出了吗?这

    2024年02月08日
    浏览(50)
  • 【C++】特殊类的设计(只在堆、栈创建对象,单例对象)

    🌏博客主页: 主页 🔖系列专栏: C++ ❤️感谢大家点赞👍收藏⭐评论✍️ 😍期待与大家一起进步! 实现方式: 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建 实现方法:

    2024年02月06日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包