✨ 人生如梦，朝露夕花，宛若泡影 🌏
🔥个人专栏：C++学习
⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞
特殊类设计和四种类型转换：
1. 特殊类设计
1.1 无法被拷贝的类
🚀🚀拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
1.1.1 C++98的做法：
- 将拷贝构造函数与赋值运算符重载只声明不定义。（防自己）
- 并且将其访问权限设置为私有即可。（防外面）
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};原因：
- 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
1.1.2 C++11的做法：
💢C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟=delete，表示让编译器删除掉该默认成员函数。
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};1.2 只能在堆上创建对象的类
实现方式如下：
思路1：
1. 将类的构造函数私有，拷贝构造声明成私有（可以直接delete掉）。防止别人调用拷贝在栈上生成对象。
注意：拷贝构造可以直接delete掉，但是构造函数不行！！因为我们还需要利用构造函数在堆上创建对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
注意：这里涉及到的是先有鸡还是先有蛋的问题，因为如果不去创建这个对象就没有办法去调用他的构造函数，但是没有调用构造函数就没有办法创建对象。所以这里必须通过静态成员函数的返回值去构造堆对象。
class HeapOnly
{
public:
//HeapOnly* CreatrObj()
static HeapOnly* CreateObject()//需要用静态的
{
return new HeapOnly;
}
private:
HeapOnly() {};
HeapOnly(const HeapOnly&) = delete;
};
int main()
{
//HeapOnly H; //这个不行
HeapOnly* p = HeapOnly::CreateObject();
return 0;
}
思路2：
1、相比较于上一种思路把构造函数私有、拷贝构造delete，也可以选择将析构函数给设成私有。
析构函数设置成私有同样会导致对象无法在栈上进行创建。因为自定义类型在栈帧中销毁的时候会去自动调用他的析构函数，但是因为调不到所以会报错。
2、封装一个destory的成员函数，这样我们可以手动释放堆空间的资源。
在堆上创建对象是用指针去接受，所以并不影响，但是内存需要我们去手动释放，因此我们需要封装destory的成员函数去调用delete，这样delete可以对应调用到析构函数。 这里有两个方案：一种是设置能静态成员函数（类域调用），一种是设置成普通成员函数（对象自己调用）。
class HeapOnly
{
public:
//方案1
static void Destroy(HeapOnly* hp)
{
delete hp;
}
//方案2
void Destroy()
{
delete this;
}
private:
~HeapOnly() {};
};
int main()
{
//HeapOnly H; 调不到析构函数，无法创建
//静态成员函数释放
HeapOnly* hp1 = new HeapOnly;
HeapOnly::Destroy(hp1);
//HeapOnly hp(*hp1);
//普通成员函数释放
HeapOnly* hp2 = new HeapOnly;
hp2->Destroy(); //手动释放
return 0;
}1.3 只能在栈上创建对象的类
💢new和delete是全局的运算符重载函数，因此我们只要将这两个给禁用掉，就不会在堆上创建对象。
🍉1.3.1 实现一：
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
// 封死拷贝构造
//StackOnly(const StackOnly& s) = delete;
// 禁掉operator new
void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;
private:
StackOnly()
:_a(0)
{}
private:
int _a;
};
int main()
{
// 1.由于构造私有化，无法直接构造
//static StackOnly s1;
//StackOnly s2;
//StackOnly* s3 = new StackOnly;
// 2.在栈上创建对象，如果封死拷贝构造，
//由于封死了拷贝构造，Creatrobj也无法调用，因此下面我们都不封拷贝构造
StackOnly s4 = StackOnly::CreateObj();
// 3. 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
StackOnly* s5 = new StackOnly(s4); //拷贝构造
// 4.由于拷贝构造没封，即使封死了operator new，也可以调用
static StackOnly s6(s4); // 静态区
return 0;
}🥝1.3.2 实现二：
🚀由于仍然是没有严格的封死，因此我们还是得封拷贝构造， 但是导致上面之前得都走不通
但是因为我们这里实现了拷贝构造，那么这里就不会默认生成移动构造了，因此我们得写出移动构造
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
// 封死拷贝构造
StackOnly(const StackOnly& s) = delete;
// 提供移动构造
StackOnly(StackOnly&& s)
{}
private:
StackOnly()
:_a(0)
{}
private:
int _a;
};
int main()
{
// 1.由于构造私有化，无法直接构造
//static StackOnly s1;
//StackOnly s2;
//StackOnly* s3 = new StackOnly;
// 2.拷贝构造封死，然后再调用移动构造，就可以彻底封死了
StackOnly s4 = StackOnly::CreateObj();
//StackOnly* s5 = new StackOnly(s4);
//static StackOnly s6(s4);
// 3.漏洞
static StackOnly s7(move(s4)); //移动构造
StackOnly* s8 = new StackOnly(move(s4));
return 0;
}1.4 无法被继承的类
1.4.1 C++98的做法：
💢构造函数私有化，这样子类调用不到父类的构造函数，无法实现继承
// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};1.4.2 C++11的做法：
💢直接用final关键字，可以使得该类无法被继承
class A final
{
// ....
};1.5 只能创建一个对象(单例模式)
🍍1.5.1 设计模式：
🎈设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也 是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
🎈使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
🍎1.5.2 单例模式：
☘️☘️一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式：
🌈饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
//main函数之前创建出来的就是饿汉
// 单例：全局只有唯一实例对象
///*——-------—————— 饿汉模式 ————————————*/
// 优点：简单
// 缺点：
// 1、多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序启动慢
// 2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证
class InfoMgr
{
public:
static InfoMgr& GetInstance()
{
return _ins;
}
void Print()
{
cout << _ip << endl;
cout << _port << endl;
cout << _buffSize << endl;
}
private:
InfoMgr(const InfoMgr&) = delete;
InfoMgr& operator=(const InfoMgr&) = delete;
InfoMgr()
{
cout << "InfoMgr()" << endl;
}
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t _buffSize = 1024 * 1024;
//...
static InfoMgr _ins;
};
InfoMgr InfoMgr::_ins; // 在程序入口之前就完成单例对象的初始化
int main()
{
cout << endl;
InfoMgr::GetInstance().Print();
//InfoMgr copy(InfoMgr::GetInstance());
cout << endl;
InfoMgr::GetInstance().Print();
cout << endl;
cout << &InfoMgr::GetInstance() << endl;
cout << &InfoMgr::GetInstance() << endl;
return 0;
}
注：如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。
🌈懒汉模式
☘️☘️如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
写法一：
class InfoMgr
{
public:
// 第一次调用时再去创建单例对象
// 线程安全的风险（暂时没学）
static InfoMgr& GetInstance()
{
if (_pins == nullptr) //第一次调用刚好是空
{
_pins = new InfoMgr;
}
return *_pins;
}
void Print()
{
cout << _ip << endl;
cout << _port << endl;
cout << _buffSize << endl;
}
static void DelInstance() //主动释放单例
{
delete _pins;
_pins = nullptr;
}
private:
InfoMgr(const InfoMgr&) = delete;
InfoMgr& operator=(const InfoMgr&) = delete;
InfoMgr()
{
cout << "InfoMgr()" << endl;
}
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t _buffSize = 1024 * 1024;
//...
static InfoMgr* _pins;
};
InfoMgr* InfoMgr::_pins = nullptr; //设计为指针写法二：
懒汉模式更简单的写法，C++11之后更加推荐
//懒汉模式更简单的写法，C++11之后更加推荐
class InfoMgr
{
public:
// 第一次调用时再去创建单例对象
// 线程安全的风险（暂时没学）
static InfoMgr& GetInstance()
{
//C++11之后才是这样
static InfoMgr ins; //创建一个局部的静态，因为局部的静态是在创建的时候初始化
return ins;
}
void Print()
{
cout << _ip << endl;
cout << _port << endl;
cout << _buffSize << endl;
}
private:
InfoMgr(const InfoMgr&) = delete;
InfoMgr& operator=(const InfoMgr&) = delete;
InfoMgr()
{
cout << "InfoMgr()" << endl;
}
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t _buffSize = 1024 * 1024;
//...
static InfoMgr* _pins;
};
InfoMgr* InfoMgr::_pins = nullptr; //设计为指针调用及结果示意：
int main()
{
cout << endl;
InfoMgr::GetInstance().Print();
cout << endl;
InfoMgr::GetInstance().Print();
cout << endl;
//查看多次调用时对象地址
cout << &InfoMgr::GetInstance() << endl;
cout << &InfoMgr::GetInstance() << endl;
return 0;
}
从饿汉与懒汉模式得打印结果我们可以发现，饿汉模式是先进行的全局然后再进行main函数，而懒汉模式是先进入main函数中才开始。
2. 类型转换
2.1 C语言中的类型转换
🚀🚀在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。
- 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败
- 显式类型转化：需要用户自己处理
/* ———————————— a. 内置类型——————————————————*/
//1、隐式类型转换 整形之间/整形和浮点数之间
//2、显示类型的转换 指针和整形、指针之间
int main()
{
int i = 1;
// 隐式类型转换
double d = i;
printf("%d, %.2f\n", i, d);
int* p = &i;
// 显示的强制类型转换
int address = (int)p;
printf("%p, %d\n", p, address);
return 0;
}缺陷：转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换
2.2 C++中的类型转换
标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符
🌱2.2.1 static_cast
static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用（相近类型用static_cast->意义相似的类型）
int main()
{
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
return 0;
}☘️ 2.2.2 reinterpret_cast
reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型（一定的关联，但是意义不相似的的类型用reinterpret_cast ）
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.2.3 const_cast
const_cast最常用的用途就是删除变量的const属性，方便做赋值操作（const_cast的类型必须是对象的指针或者引用）
int main()
{
// 对应强制类型转换中有风险的去掉const属性
//常变量
const int b = 2;
//int* p2 = (int*)&b; //上下两种方式效果等同
int* p2 = const_cast<int*>(&b);
*p2 = 3;
const int c = b; //在这里很明显可以看到 b 的具体值
// b 其实在内存中已经修改为3，比如在监视窗口下就是3，但是去读的时候已经变成常量2了
cout << b << " " << * p2 << " " << c << endl;
return 0;
}
思考：为什么*p被修改了，a却没有被修改？？
因为常量被存到寄存器中了，所以其实改变的是内存中的a，但是不是寄存器中的a。这其实是一种优化，如果我们想要去掉这种优化，用volatile关键字（告诉编译器不要优化，直接从内存中读取）
volatile关键字
这里我们可以使用volatile 来打印我们希望的结果 3
当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据， 即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存
int main()
{
// 我们可以使用volatile 来打印我们希望的结果 3
volatile const int b = 2;
//int* p2 = (int*)&b; //上下两种方式效果等同
int* p2 = const_cast<int*>(&b);
*p2 = 3;
const int c = b; //在这里很明显可以看到 b 的具体值
cout << b << " " << * p2 << " " << c << endl;
return 0;
}
🌿2.2.4 dynamic_cast
dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意：
- dynamic_cast只能用于父类含有虚函数的类
- dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回nullptr。
举个例子🌰：
假如存在下面这样一个类和main函数：
class A
{
public:
virtual void f() {}
int _a = 1;
};
class B : public A
{
public:
int _b = 2;
};
void fun(* pa){}
int main()
{
A a;
B b;
fun(&a);
fun(&b);
return 0;
}假如fun函数实现如下：
void fun(A* pa)
{
// 指向父类转换时有风险的，后续访问存在越界访问的风险
// 指向子类转换时安全
B* pb1 = (B*)pa;
cout << "pb1: " << pb1 << endl;
cout << "pb1->_a: " << pb1->_a << endl;
cout << "pb1->_b: " << pb1->_b << endl;
pb1->_a++;
pb1->_b++;
cout << "pb1->_a: " << pb1->_a << endl;
cout << "pb1->_b: " << pb1->_b << endl
}
因此我们就需要用到 dynamic_cast 来解决子类转换为 父类的问题
void fun(A* pa)
{
// dynamic_cast会先检查是否能转换成功(指向子类对象)，能成功则转换，
// (指向父类对象)不能则返回NULL
B* pb1 = dynamic_cast<B*>(pa);
if (pb1) //先判断是否为空
{
cout << "pb1:" << pb1 << endl;
cout << "pb1->_a: " << pb1->_a << endl;
cout << "pb1->_b: " << pb1->_b << endl;
pb1->_a++;
pb1->_b++;
cout << "pb1->_a: " << pb1->_a << endl;
cout << "pb1->_b: " << pb1->_b << endl;
}
else
{
cout << "转换失败" << endl;
}
B* pb2 = static_cast<B*>(pa);
B* pb3 = dynamic_cast<B*>(pa);
cout << "pb2: " << pb2 << endl;
cout << "pb3: " << pb3 << endl;
}
课外知识点：
1、为什么父类和子类明明是两种类型，但是向上转型不需要转换呢？？
因为子类会直接充当子类中父类那一部分的别名，不存在类型转换
2、为什么向下转型是不安全的？？
因为子类的指针或引用如果是父类对象，那么会存在一部分的越界！！！
3、为什么 dynamic_cast只能用于父类含有虚函数的类
dynamic_cast转换是在运行时进行转换，因为只有对于这种类层次结构，才应该将派生类的地址赋给基类指针。运行时转换就需要知道类对象的信息（继承关系等）。C++对象模型中，对象实例最前面的就是虚函数表指针，通过这个指针可以获取到该类对象的所有虚函数，包括父类的。因为派生类会继承基类的虚函数表，所以通过这个虚函数表，我们就可以知道该类对象的父类，在转换的时候就可以用来判断对象有无继承关系。
所以虚函数对于正确的基类指针转换为子类指针是非常重要的。
4、dynamic_cast的使用原理
父类指针或引用如果本来指向的是子类的对象，那么类型转化是安全的，如果原本指向的是父类的对象，那么转化是不安全的（有越界，但是编译器检查不出来)，所以dynamic_cast可以帮助我们去判断这种情况，如果不符合安全转化的条件，就会返回nullptr。
2.3 为什么C++需要四种类型转换
C风格的转换格式很简单，但是有不少缺点的：
- 隐式类型转化有些情况下可能会出问题：比如数据精度丢失
- 显式类型转换将所有情况混合在一起，代码不够清晰
- 为了提供更安全、更明确的类型转换，使得代码意图更为清晰
因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。因此C++的转化风格并非强制性的，只不过是程序员之间的一种规范。
2.4 RTTI
RTTI：Run-time Type identification的简称，即：运行时类型识别。RTTI只适用于包含虚函数的类。
C++通过以下方式来支持RTTI：
- typeid运算符（返回指出对象类型的值）
- dynamic_cast运算符（根据虚基表判断有无继承关系，并判断是否可以转化）
- decltype（推断表达式返回值的类型）
2.5 扩展
2.5.1 内置类型和自定义类型之间
由于自定义类型无法像内置类型那样转换，因此我们要实现实现一个 operator int() 的函数来进行转换，详情请看下面代码及注解（注：explicit 可禁止隐式类型转换）
/* ———————————— b. 内置类型和自定义类型之间——————————————————*/
//1、自定义类型 = 内置类型 -> 构造函数支持 （单参数和多参数的隐式类型转换时通过构造函数来支持的）
// 2、内置类型 = 自定义类型 （自定义类型，转化为内置类型）
class A {
public:
//explicit A(int a) //禁止隐式类型转换
A(int a)
:_a1(a)
, _a2(a)
{}
A(int a1,int a2)
:_a1(a1)
, _a2(a2)
{}
//int operator()() 中()被仿函数占用了，不能用
// operator 类型实现，无返回类型
// 自定义类型转换为内置类型
//explicit operator int()
operator int()
{
return _a1 + _a2;
}
private:
int _a1 = 1;
int _a2 = 1;
};
int main()
{
//单参数的隐式类型转换
//在其对应的构造函数那加了explicit关键字，就不支持隐式类型转换
//A aa1 = 1; //单参数类型转换为自定义类型，靠构造函数转的
A aa1 = A(1);//但是还是支持转换
//多参数的隐式类型转换
A aa2 = { 2,2 };
const A& aa3 = { 2,2 };
//int z = aa1.operator int();//本质是这个
int x = aa1; //隐式类型转换
int y = (int)aa2; //显式类型转换
cout << x << " " << y << endl;
//智能指针的条件逻辑判断
std::shared_ptr<int> foo;
std::shared_ptr<int> bar(new int(34));
//if (foo.operator bool())
if (foo)
std::cout << "foo points to " << *foo << '\n';
else
std::cout << "foo is null\n";
if (bar)
std::cout << "bar points to " << *bar << '\n';
else
std::cout << "bar is null\n";
return 0;
}
2.5.2 自定义类型与自定义类型之间
/* ———————————— c. 自定义类型和自定义类型之间——————————————————*/
// c、自定义类型和自定义类型之间 -- 需要书写对应的构造函数支持
class A {
public:
A(int a)
:_a1(a)
, _a2(a)
{}
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
int get()const
{
return _a1 + _a2;
}
private:
int _a1 = 1;
int _a2 = 1;
};
class B
{
public:
B(int b)
:_b1(b)
{}
B(const A&aa)
:_b1(aa.get())
{}
private:
int _b1 = 1;
};
#include "List.h"
int main()
{
A aa1(1);
B bb1(1);
//aa1 = bb1;
bb1 = aa1;
B& ref1 = bb1;
//B& ref2 = aa1;
const B& ref2 = aa1;
qian::list<int> l1 = { 1,2,3,4 };
//权限的缩小？ 权限的缩小和放大，仅限于const的指针和引用
// 不是权限缩小，这里是类型转换
qian::list<int>::const_iterator cit = l1.begin();
while (cit != l1.end())
{
cout << *cit << " ";
++cit;
}
cout << endl;
return 0;
}注：
🔥我们是在该文章 C++/STL】list容器的深度剖析及底层实现-CSDN博客 的完整代码作为List.h文件下，加了这一段话到其头文件中
//支持const迭代器与普通迭代器的转换
ListIterator(const ListIterator<T, T&, T*>& it)
:_node(it._node)
{}2.6 建议
🔥 强制类型转换关闭或挂起了正常的类型检查，每次使用强制类型转换前，程序员应该仔细考虑是否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制转换值的作用域，以减少发生错误的机会。强烈建议：避免使用强制类型转换
📖后言
以上就是特殊类设计及类型转换的全部类型啦💞 💞 💞那么本篇到此就结束，希望我的这篇博客可以给你提供有益的参考和启示，感谢大家支持！！！祝大家天天开心
4256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
