单列模式和C++中的类型转换

是个西兰花2026-05-13 13:27

1.设计模式：单列模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单列模式：一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

单列模式有两种实现模式：

1.1 饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

cpp 复制代码 
class A
{
public:
	//就是全局函数，只是受类域限制
	static A* GetInstance() //static 才能类外调用，也可以返回引用
	{
		return &_inst;
	}

	void Add(const string& key, const string& value)
	{
		_dict[key] = value;
	}

	void Point()
	{
		for (auto& kv : _dict)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	A(){}; //构造函数
	A(const A& aa) = delete;//禁掉拷贝构造
	A& operator=(const A& aa) = delete;//禁掉赋值一般一块禁掉

	map<string, string> _dict;
	int _n; 

	//就是全局变量，只是受类域限制
	static A _inst;//不是自己创建自己，静态不在对象里面，存在静态区。这是声明,可以调用类内的构造
};

//类外定义：（main函数启动前）创建好  
A A::_inst; ////instance（_inst） 是全局静态变量，程序一启动、进入 main 之前就已经构造好了，不是你调用 GetInstance() 才创建。

int main()
{
	A::GetInstance()->Add("sort", "排序");
	A::GetInstance()->Add("left", "左边");
	A::GetInstance()->Add("right", "右边");
	A* p = A::GetInstance();//获取的都是同一个
	p->Add("right", "wdz");
	A::GetInstance()->Point();


	//A copy(*A::GetInstance()); //所以要禁掉拷贝构造函数
	//*A::GetInstance() = *A::GetInstance(); //禁掉 赋值运算符重载
	
	return 0;
}
  • 构造函数不能在 public：中
  • 对象在自己类域内 static 创建
  • 使用时调用 static 成员函数获得对象

饿汉模式只用全局对象不行，因为构造函数时需要私有，无法再外部调用。

  • 饿汉模式的优点：实现简单。
  • 饿汉模式的缺点：可能会导致线程启动慢。如何两个单例有启动先后顺序，那么饿汉无法控制（因为可能在不同文件被其他全局对象依赖，这样两个对象之间便有了依赖关系）

1.2 懒汉模式

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

cpp 复制代码 
class B
{
public:
	//就是全局函数，只是受类域限制
	static B* GetInstance() //static 才能类外调用，也可以返回引用
	{
		if (_inst == nullptr)
			_inst = new B;
		return _inst;
	}

	void Add(const string& key, const string& value)
	{
		_dict[key] = value;
	}

	void Point()
	{
		for (auto& kv : _dict)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}
	~B()
	{
		//持久化操作，比如将数据写到文件
		cout << "~B" << endl;
	}
	static void DeIInstance()//别人想提前析构调也可以调
	{
		if (_inst != nullptr)
		{
			delete _inst;
			_inst = nullptr;
		}
	}

private:
	B(){ };

	B(const B& aa) = delete;//禁掉拷贝构造
	B& operator=(const B& aa) = delete;//禁掉赋值一般一块禁掉
	
	map<string, string> _dict;
	int _n;

	//就是全局变量，只是受类域限制
	static B* _inst;
//内部类不是外部类的成员，因此默认不能访问外部类的私有成员，除非外部类显式声明 friend class B;
	class gc
    {
	public:
		~gc()
		{
			DeIInstance();// 内部类只能访问外部类的静态 还是相互独立，只是作用域变化
		}
	};
	static gc _gc;
};

B* B::_inst = nullptr;
B::gc B::_gc;//全局对象，（main/程序）执行完 期望会主动析构_inst

int main()
{
	B::GetInstance()->Add("sort", "排序");
	B::GetInstance()->Add("left", "左边");
	B::GetInstance()->Add("right", "右边");
	B* p = B::GetInstance();//获取的都是同一个
	p->Add("right", "wdz");
	B::GetInstance()->Point();

	//A copy(*A::GetInstance());
	//*A::GetInstance() = *A::GetInstance();

	delete p;//期望main函数结束前自动调用  
	return 0;
}

懒汉模式有一个问题：线程安全，如果多个同时new _inst时会出现问题，我们后面文章会做讲解，new 的懒汉对象一般是不需要释放，因为它是单例全局作用，进程正常结束会释放，如果想要显示释放，可以使用 delete 或 全局内部类对象的方法（外部类也可以）释放。

  • 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制，先执行的会首先构造。
  • 缺点：复杂

2. C++中的类型转换

2.1 C语言中的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

  1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败
  2. 显式类型转化：需要用户自己处理
cpp 复制代码 
void Test ()
{
    int i = 1;
    // 隐式类型转换
    double d = i;
    printf("%d, %.2lf\n" , i, d);
    int* p = &i;
    // 显示的强制类型转换
    int address = (int) p;
    printf("%x, %d\n" , p, address);
}

**缺陷：**转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换。

2.2 为什么C++需要四种类型转换

C风格的转换格式很简单，但是有不少缺点的：

  1. 隐式类型转化有些情况下可能会出问题：比如数据精度丢失
  2. 显式类型转换将所有情况混合在一起，代码不够清晰

因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格

2.3 C++强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：static_cast、reinterpret_cast、const_cast、dynamic_cast

2.3.1 static_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关的类型进行转换。size_t 和 int 会隐式类型转换，小于 0 时会出现问题。显示类型转换容易被人注意到。

cpp 复制代码 
int main()
{
    //相近类型用static_cast->意义相近 的类型
    double d = 12.34;
    int a = static_cast<int>(d);//对应c语言隐式类型转换 
    cout<<a<<endl;
    return 0;
}

2.3.2 reinterpret_cast

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型，指针和整型不是相似类型，需要使用reinterpret_cast。

cpp 复制代码 
int main()
{
    double d = 12.34;
    int a = static_cast<int>(d);
    cout << a << endl;
    
    // 这里使用static_cast会报错，应该使用reinterpret_cast
    //int *p = static_cast<int*>(a);
    
    int *p = reinterpret_cast<int*>(a);
    
    return 0;
}

2.3.3 const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值

cpp 复制代码 
int main()
{
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << a << endl;//结果是2
	cout << *p << endl;
	cout << &a << endl;
	cout << p << endl;
	return 0;
}

在vs环境下运行，发现输出a的值还是2，没有被修改：

因为这里编译器发生了优化，认为 const 变量不会被修改，直接放到寄存器中，或者define为常量，所以有可能以后直接从编译器中读2，不存在内存中，但他们地址却相同。

我们可以使用 volatile 表示被修饰的变量的值可能会在程序的控制流之外被改变，但结果发现a的地址是1。 所以不要试图为这些诡异数字找一个精确的"编译器优化原理"，因为它们本身就是"无原理可讲"的未定义行为垃圾结果，C++认为const变量不能被修改。

2.3.4 dynamic_cast

dynamic_cast 是 C++ 中专门用于多态类型的运行时类型识别（RTTI）转换操作符。它允许在类的继承层次结构中安全地进行向下转换（从基类到派生类）或横向转换（到兄弟类）。

核心行为：

  1. 向下转换（基类 → 派生类）

    如果 expression 实际指向/引用的对象是 TargetType 类型或由其公有派生的类型，转换成功；否则失败。

  2. 横向转换

    在多重继承中，可将基类指针转换为另一个基类指针（兄弟类），只要实际对象同时派生自两者。

  3. 转换为 void*
    dynamic_cast<void*>(expression) 返回指向实际对象（最派生对象）的指针。

  4. 失败处理

    • 指针版本：失败返回 nullptr。

    • 引用版本：失败抛出 std::bad_cast 异常。

注意：

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

首先复习一下，子类对象/指针赋值给父类对象/指针/引用，中间不产生临时变量。

  • 向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则，不产生临时变量)
  • 向下转型：父类对象指针/引用->子类指针/引用(需要使用dynamic_cast转型是安全的)
cpp 复制代码 
class A
{
public:
	virtual void f() {}

	int _a = 0;
};

class B : public A
{
public:
	virtual void f() {}

	int _b = 1;
};

int main()
{
	A obja;
	B objb;

	obja = objb;//不会产生临时变量

	A& ra = objb;//不会产生临时变量

	double d = 1.1;//会产生临时变量
	const int& i = d;

	return 0;
}

应用场景：由于A*是父类指针，传入子类也可以调用，但传入父类之后强制类型转换为子类是不安全的，比如 fun1 函数：

cpp 复制代码 
void fun1(A* pa) //子类父类都可以调用
{
	//直接转换是不安全的
	B* ptr = (B*)pa;
	ptr->_a++;
	ptr->_b++;//如果是父类调用 ， 是没有 _b
}

void fun(A* pa)
{
	B* ptr = dynamic_cast<B*>(pa);//pa 必须支持多态     
	if (ptr)//可以间接识别出 pa指向父类还是子类
	{
		ptr->_a++;
		ptr->_b++;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

RTTI：Run-time Type identification的简称，即：运行时类型识别。

C++通过以下方式来支持RTTI：

  1. typeid运算符
  2. dynamic_cast运算符
  3. decltype

本篇结束！

相关推荐
诙_1 小时前
C++代码实践应用
开发语言·c++
多加点辣也没关系1 小时前
设计模式-享元模式
数据库·设计模式·享元模式
Little At Air1 小时前
LinuxOS阻塞队列模型（单生产者单消费者）
linux·数据结构·c++
念恒123062 小时前
基础IO(一切皆文件)
linux·c语言·c++·算法
Irissgwe2 小时前
四、进程控制（进程创建与终止）
linux·c++·进程·系统编程·fork·进程创建·进程终止
代钦塔拉2 小时前
第一篇：工业级 C++/Qt 项目头文件包含原则：告别循环依赖与编译玄学
开发语言·c++·qt
熠熠仔3 小时前
《Agentic Design Patterns》概览
学习·设计模式
ZPC82103 小时前
规划后的轨迹，如何发给 moveit_servo 执行
c++·人工智能·算法·3d
杜子不疼.3 小时前
【C++ 在线五子棋对战】 - 工具类模块实现
开发语言·c++
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03【AI】2026 年具身智能模型和世界模型总结04CC-Switch & Claude 基于 Linux 服务器安装使用指南05零基础教你claude code 接入 deepseek V406Cursor 接入 DeepSeek‑V4‑Pro 完整指南（2026 实测）07codex app每次打开重连5次Reconnecting问题解决08Windows端Codex接入第三方模型（DeekSeek，BaiLian)09要裂开了！ChatGPT要手机号验证了？注册Codex要求验证电话号码怎么办？2026年登陆Codex要手机号验证的解决办法10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法