山东外贸建站,自己电脑做网站,网站建设教程在线观看,深圳手机集团网站建设目录 #x1f4a1;前言一#xff0c;特殊类设计1. 请设计一个类#xff0c;不能被拷贝2. 请设计一个类#xff0c;只能在堆上创建对象3. 请设计一个类#xff0c;只能在栈上创建对象4. 请设计一个类#xff0c;不能被继承5. 请设计一个类#xff0c;只能创建一个对象(单… 目录 前言一特殊类设计1. 请设计一个类不能被拷贝2. 请设计一个类只能在堆上创建对象3. 请设计一个类只能在栈上创建对象4. 请设计一个类不能被继承5. 请设计一个类只能创建一个对象(单例模式)5.1 饿汉模式5.2 懒汉模式 二类型转换1. 内置类型之间2. 内置类型和自定义类型之间3. 自定义类型和自定义类型之间 三C强制类型转换1. static_cast2. reinterpret_cast3. const_cast4. dynamic_cast 前言
本篇文章的内容是C的拓展学习主要介绍在某些特定场合下的一些特殊类的设计并且总结了C/C中的类型转换。
一特殊类设计
1. 请设计一个类不能被拷贝
拷贝只会发生在两个场景中拷贝构造函数以及赋值运算符重载因此想要让一个类禁止拷贝只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
(1) C98的写法 将拷贝构造函数与赋值运算符重载只声明不定义并且将其声明为私有即可。 class CopyBan
{// ...private:CopyBan(const CopyBan cb);CopyBan operator(const CopyBan cb);//...
};原因
1.设置成私有如果只声明没有设置成private用户自己如果在类外定义了就可以不能禁止拷贝了。
2.只声明不定义不定义是因为该函数根本不会调用定义了其实也没有什么意义不写反而还简单而且如果定义了就不会防止成员函数内部拷贝了。
(2) C11写法 C11扩展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) C98方式 C98中构造函数私有化派生类中调不到基类的构造函数。则无法继承。 class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
};(2) C11方法 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) C98方式
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) C11方式
class InforMgr
{
public:// 获取对象static InforMgr GetInstance(){// 局部静态第一次调用时才创建单例对象// C11之后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_castint(d);coutaendl;return 0;
}2. reinterpret_cast reinterpret_cast 对应强制类型转换 – 数据的意义已经发生改变。 int main()
{double d 12.34;int a static_castint(d);cout a endl; // 12// 对应强制类型转换--数据的意义已经发生改变int* p1 reinterpret_castint*(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_castB*(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;
}
