【C++】特殊类设计类型转换

💡前言

本篇文章的内容是C++的拓展学习，主要介绍在某些特定场合下的一些特殊类的设计，并且总结了C/C++中的类型转换。

一，特殊类设计

1. 请设计一个类，不能被拷贝

拷贝只会发生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

(1) C++98的写法

将拷贝构造函数与赋值运算符重载只声明不定义，并且将其声明为私有即可。

class CopyBan
{// ...private:CopyBan(const CopyBan& cb);CopyBan& operator=(const CopyBan& cb);//...
};

原因：

1.设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了。

2.只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

(2) C++11写法

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。

class CopyBan
{// ...CopyBan(const CopyBan& cb)=delete;CopyBan& operator=(const CopyBan& cb)=delete;//...
};

2. 请设计一个类，只能在堆上创建对象

实现方式1：

(1) 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
(2) 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

class HeapOnly
{
public:// 只打开唯一的通道在堆上newstatic HeapOnly* CreateObj(){return new HeapOnly;}HeapOnly(const HeapOnly& hp) = delete;HeapOnly operator=(const HeapOnly& hp) = delete;
private:// 构造函数私有化HeapOnly(){}
};int main()
{HeapOnly* hp = HeapOnly::CreateObj();delete hp;return 0;
}

实现方式2：

(1) 将类的析构函数私有，让其他实例化出的对象无法销毁。
(2) 直接在堆上new对象，再提供一个公有的delete函数。

class HeapOnly
{
public:void  Destory(){delete this;}private:// 析构函数私有化~HeapOnly(){}
};int main()
{HeapOnly* hp = new HeapOnly;hp->Destory();return 0;
}

3. 请设计一个类，只能在栈上创建对象

实现方式：

同上将构造函数私有化，然后设计静态方法创建对象返回即可。

class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}//StackOnly(const StackOnly& s) = delete;void* operator new(size_t size) = delete;void operator delete(void* p) = delete;
private:StackOnly():_a(0){}
private:int _a;
};int main()
{StackOnly s4 = StackOnly::CreateObj();return 0;
}

4. 请设计一个类，不能被继承

(1) C++98方式

C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承。

class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
};

(2) C++11方法

final关键字，final修饰类，表示该类不能被继承。

class A  final
{// ....
};

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

单例：全局只有唯一实例化对象。

5.1 饿汉模式

饿汉模式就是：进入min函数之前创建好对象，需要时直接调用公有函数获取。

class InforMgr
{
public:// 获取对象static InforMgr& GetInstance(){return _ins;}// 这个函数只是用来说明问题void Print(){cout << _ip << endl;cout << _port << endl;}private:InforMgr(const InforMgr& ins) = delete;InforMgr& operator=(const InforMgr& ins) = delete;InforMgr(){cout << "InforMgr()" << endl;}
private:string _ip = "100.02.4";size_t _port = 3;//提前创建一个静态的全局对象static InforMgr _ins;
};//在类外定义
InforMgr InforMgr::_ins;int main()
{InforMgr::GetInstance().Print();return 0;
}

饿汉模式的问题：

(1) 有多个饿汉模式的单例存在，某个对象初始化内容较多(读文件)，会导致程序启动慢。
(2) A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，B在初始化，饿汉无法保证。

5.2 懒汉模式

懒汉模式就是：不是提前创建好对象，而是什么时候需要，什么时候创建。

(1) C++98方式：

class InforMgr
{
public:// 获取对象static InforMgr& GetInstance(){// 第一次调用才new一个单例对象出来if (_pins == nullptr)_pins = new InforMgr;// 后面再调用时就直接返回这个对象return *_pins;}void Print(){cout << _ip << endl;cout << _port << endl;}private:InforMgr(const InforMgr& ins) = delete;InforMgr& operator=(const InforMgr& ins) = delete;InforMgr(){cout << "InforMgr()" << endl;}
private:string _ip = "100.02.4";size_t _port = 3;static InforMgr* _pins;
};// 在类外定义
InforMgr* InforMgr::_pins = nullptr;int main()
{InforMgr::GetInstance().Print();return 0;
}

(2) C++11方式：

class InforMgr
{
public:// 获取对象static InforMgr& GetInstance(){// 局部静态，第一次调用时才创建单例对象// C++11之后static InforMgr ins;return ins;}void Print(){cout << _ip << endl;cout << _port << endl;}private:InforMgr(const InforMgr& ins) = delete;InforMgr& operator=(const InforMgr& ins) = delete;InforMgr(){cout << "InforMgr()" << endl;}
private:string _ip = "100.02.4";size_t _port = 3;static InforMgr* _pins;
};// 在类外定义
InforMgr* InforMgr::_pins = nullptr;int main()
{InforMgr::GetInstance().Print();return 0;
}

懒汉模式的问题：

线程安全的风险

二，类型转换

1. 内置类型之间

隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败。显式类型转化：需要用户自己处理。

1、隐式类型转换：整形之间/整形和浮点数之间
2、显示类型的转换：指针和整形、指针之间

int main()
{int i = 1;// 隐式类型转换double d = i;printf("%d, %.2f\n", i, d);int* p = &i;// 显示的强制类型转换int address = (int)p;printf("%x, %d\n", p, address);return 0;
}

2. 内置类型和自定义类型之间

1、内置类型转换为自定义类型 -> 通过构造函数实现。
2、自定义类型转换为内置类型 -> 通过operator 类型实现。

class A
{
public://explicit A(int a)A(int a):_a1(a),_a2(a){}A(int a1, int a2):_a1(a1), _a2(a2){}// ()被仿函数占用了，不能用// operator 类型实现，无返回类型//explicit operator int()operator int(){return _a1 + _a2;}
private:int _a1 = 1;int _a2 = 1;
};int main()
{string s1 = "1111111";A aa1 = 1; // 单参数隐式类型转换//A aa1 = (A)1; // okA aa2 = { 2,2 }; // 多参数隐式类型转换const A& aa3 = { 2,2 };// 自定义->内置int x = (int)aa1;//本质是：//int z = aa1.operator int();int x = aa1;int y = aa2;cout << x << endl;cout << y << endl;return 0;
}

3. 自定义类型和自定义类型之间

通过对应法构造函数实现

class A
{
public://explicit A(int a)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){}// 把A转换成BB(const A& aa):_b1(aa.get()){}private:int _b1 = 1;
};int main()
{A aa1(1);B bb1(2);bb1 = aa1;B& ref1= bb1;const B& ref2 = aa1;return 0;
}

三，C++强制类型转换

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

1. static_cast

static_cast 对应隐式类型转换 – 数据的意义没有改变。

int main()
{double d = 12.34;int a = static_cast<int>(d);cout<<a<<endl;return 0;
}

2. reinterpret_cast

reinterpret_cast 对应强制类型转换 – 数据的意义已经发生改变。

int main()
{double d = 12.34;int a = static_cast<int>(d);cout << a << endl; // 12// 对应强制类型转换--数据的意义已经发生改变int* p1 = reinterpret_cast<int*>(a);return 0;
}

3. const_cast

const_cast 对应强制类型转换中有风险的去掉const属性。

void Test ()
{const int a = 2;int* p = const_cast< int*>(&a);*p = 3;cout<< a <<endl; // 2
}

4. dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)。

向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)。

向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)。

注意：

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

1.没有用 dynamic_cast 时：

class A
{
public:virtual void f() {}int _a = 1;
};class B : public A
{
public:int _b = 2;
};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 << endl;//cout << pb1->_b << endl;
}int main()
{A a;B b;fun(&a);fun(&b);return 0;
}

2.使用 dynamic_cast 时：

dynamic_cast 会先检查是否能转换成功，若指向子类对象，就能成功则转换，若指向父类对象，不能转换成功，则返回NULL。

class A
{
public:virtual void f() {}int _a = 1;
};class B : public A
{
public:int _b = 2;
};void fun(A* pa)
{// dynamic_cast会先检查是否能转换成功(指向子类对象)，能成功则转换，// (指向父类对象)不能则返回NULLB* pb1 = dynamic_cast<B*>(pa);if (pb1){cout << "pb1:" << pb1 << endl;cout << "pb1->_a = " << pb1->_a << endl;cout << "pb1->_b = " << pb1->_b << endl; cout << endl;pb1->_a++;pb1->_b++;cout << "pb1->_a = " << pb1->_a << endl;cout << "pb1->_b = " << pb1->_b << endl;}else{cout << "转换失败" << endl << endl;}
}int main()
{A a;B b;fun(&a);fun(&b);return 0;
}