一、特殊类设计
在普通类的设计基础上,提出一些限制条件设计的类就是特殊类。
1、请设计一个类,不能被拷贝
拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝, 只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98中的方式:
将拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可。
class CopyBan
{
// ...
public:
CopyBan()
{}
private:
CopyBan(const CopyBan&);//拷贝构造函数声明
CopyBan& operator=(const CopyBan&);//赋值运算符重载声明
//...
};
原因:
- 1. 设置成私有:如果只声明没有设置成private,用户自己如果在类外定义了,就可以不 能禁止拷贝了
- 2. 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写 反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。
如上图代码,在对这个特殊类进行拷贝和赋值的时候,因为这两个成员函数私有而无法调用。
- 拷贝构造以及赋值运算符重载等成员函数,在调用时都是编译器在域外调用,所以必须是公有的。
C++11 :
C++11扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上 =delete,表示让编译器删除掉该默认成员函数。
class CopyBan
{
// ...
public:
CopyBan()
{}
CopyBan(const CopyBan&) = delete;
CopyBan& operator=(const CopyBan&) = delete;
//...
};
- 使用C++11中的给delete新赋予的意义来禁止生产拷贝构造和赋值运算符重载函数。
此时编译器也不会自动生成默认的拷贝构造和赋值运算符重载函数。
2. 请设计一个类,只能在堆上创建对象
实现方式:
- 1. 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 2. 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly;
}
private:
HeapOnly() {}
// C++98
// 1.只声明,不实现。因为实现可能会很麻烦,而你本身不需要
// 2.声明成私有
HeapOnly(const HeapOnly&);
// or
// C++11
HeapOnly(const HeapOnly&) = delete;
};
定义一个静态成员函数,在该函数内部new
一个HeapOnly
对象。将构造函数和拷贝构造函数私有,并且禁止生成拷贝构造函数。
原因:
- 使用静态成员函数new一个HeapOnly对象。
非静态成员函数在调用的时候,必须使用点(.)操作符来调用,这一步是为了传this指针。
这样的前提是先有一个HeapOnly对象,但是构造函数设置成了私有,就无法创建这样一个对象。
而静态成员函数的调用不用传this指针,也就不用必须有HeapOnly对象,只需要类域::静态成员函数即可。
静态成员函数属于HeapOnly
域内,所以在new一个对象的时候,可以调用私有的构造函数。
- 禁止调用拷贝构造函数,并且私有化。
这样的目的是为了禁止拷贝,防止使用堆区上的HeapOnly
对象在栈区上拷贝,如下面代码
而禁止了拷贝构造就杜绝了这一行为,从而保证了HeapOnly
对象只能在堆上创建。
3. 请设计一个类,只能在栈上创建对象
方法一:同上将构造函数私有化,然后设计静态方法创建对象返回即可。
- 主要要做到不能在堆上创建类对象。
- new一个对象的时候,会调用该类的
operator new(size_t size)
函数,在释放资源的时候又会调用该类的operator delete(void* p)
函数。
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
// StackOnly obj = StackOnly::CreateObj();
// StackOnly* ptr3 = new StackOnly(obj);
void* operator new(size_t size) = delete;//禁止调用new
void operator delete(void* p) = delete;//禁止调用delete
private:
int _a;
};
- 使用
delete
来禁止这两个函数的调用,那么在new
一个对象的时候,就会产生编译错误,从而无法在堆区上创建类对象。
此时在堆上创建对象时就会报错,尝试引用已经删除的函数。
方法2:
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
private:
StackOnly()
:_a(0)
{}
private:
int _a;
};
另一种方式就是和之前一样,通过一个静态成员函数在栈区上创建一个类对象,并且将默认构造函数私有化。
此时new
一个对象的时候,由于默认构造函数私有无法调用,所以报错。
但是这俩种设计方法都有一个漏洞,类对象可以在静态区(数据段)上创建:
static StackOnly num = StackOnly::CreateObject();
设计特殊类的核心点:只能通过静态成员函数来创建类,封掉其他所有创建方式。
4 .不能被继承的类
C++98方式
// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
原因:
- 基类的构造函数私有,派生类在创建对象的时候,无法调用基类的构造函数。
此时我们就设计出了不能继承的类。
C++11的方式:
inal关键字,final修饰类,表示该类不能被继承。
class A final
{
// ....
};
使用C++11中的final
关键字修饰基类,这个基类就无法继承。
5.单例模拟
单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时,为了防止频繁地创建对象使得内存飙升,单例模式可以让程序仅在内存中创建一个对象,让所有需要调用的地方都共享这一单例对象。
- 单例模式:一个类只能创建一个对象。
- 该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。
5.1 单例模式的类型
单例模式有两种类型:
- 懒汉式:在真正需要使用对象时才去创建该单例类对象
- 饿汉式:在类加载时已经创建好该单例对象,等待被程序使用
懒汉式创建单例对象
懒汉式创建对象的方法是在程序使用对象前,先判断该对象是否已经实例化(判空),若已实例化直接返回该类对象。否则则先执行实例化操作。
根据上面的流程图,就可以写出下面的这段代码
class Singleton
{
public:
static Singleton* GetInstance()
{
//如果单例对象没有创建则在堆区创建
if (m_pInstance == nullptr)
{
m_pInstance = new Singleton;
}
return m_pInstance;
}
private:
//构造函数
Singleton()
{}
Singleton(const Singleton& s) = delete;//禁止拷贝
Singleton& operator=(const Singleton& s) = delete;//禁止赋值
//静态单例对象指针
static Singleton* m_pInstance;//单例对象指针
};
Singleton* Singleton::m_pInstance = nullptr;//初始化为空
- 将构造函数私有,拷贝构造和赋值运算符重载函数禁止调用,用来保证单例模式的唯一性。
- 增加静态单例对象指针成员变量。
在类外实例化静态指针变量的时候,并没有创建单例对象,而是将其初始化为空。
int main()
{
Singleton* ps = Singleton::GetInstance();//获取单例对象
return 0;
}
懒汉模式又叫做延时加载模式,如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。
优点:
- 第一次使用单例对象时才创建对象,进程启动过程中无负载。
- 多个互相依赖的单例可以控制启动顺序(通过代码顺序)。
饿汉式创建单例对象
饿汉式在类加载时已经创建好该对象,在程序调用时直接返回该单例对象即可,即我们在编码时就已经指明了要马上创建这个对象,不需要等到被调用时再去创建。
class Singleton
{
public:
//获取单例对象接口
static Singleton* GetInstance()
{
return &m_instance;
}
private:
Singleton()
{}
Singleton(const Singleton& s) = delete;//禁止使用拷贝构造
Singleton& operator=(const Singleton& s) = delete;//禁止使用赋值运算符重载
//保证单例对象在静态区且只有一个
static Singleton m_instance;//单例对象
};
Singleton Singleton::m_instance;//在程序入口之前就完成单例对象初始化
静态成员变量只能在类域外进行定义初始化。
所以在main函数之前就将单例对象定义初始化,此时该单例对象创建在静态区上,而且仅有一个,后面就无法再创建。
- 想要获取该单例对象只能通过静态成员函数
GetInstance()
来获取。- 静态成员函数可以直接访问静态成员变量
m_instance
。
int main()
{
Singleton* s = Singleton::GetInstance();//获取单例对象
return 0;
}
不管将来会不会使用到这个单例对象,但是在程序一启动还没有进入main函数之前就创建一个唯一的实例对象。
就像一个饿汉一样,一上来就创建单例对象。
缺点:
- 可能会导致进程启动较慢,如过实例对象很复杂,在创建实例对象时就会花费很多时间。
- 实例顺序不确定,如果有多个单例对象,并且对象之间存在互相依赖关系,由于对象的实例对象不确定(和代码顺序无关,由编译器决定),此时就会发生错误。
线程安全问题:
在C++11之后饿汉模式是没有线程安全问题的(做了相关补丁),因为单例对象是在main函数之前就实例化的,而多线程都是在main函数里面启动的。
但是懒汉模式是存在线程安全问题的,当多个线程使用到单例对象时候,在使用GetInstance()获取对象时,用因为调度问题出现误判,导致new多个单例对象。
- 在
GetInstance()
中判断是否创建单例的时候加锁,判断完后再解锁,让多线程串行访问单例对象的指针。
互斥锁必须放在静态区:
- 单例对象只有一个,所以全局只使用一把锁即可,放在静态区刚合适。
-
GetInstance()
是静态成员函数,没有this指针,如果互斥锁是普通成员变量的化,无法访问。而静态成员函数可以直接访问静态成员变量。
通过加锁的方式就能保证懒汉模式的线程安全问题。
双检查加锁:
- 此时,每个调用
GetInstance()
的线程都需要申请锁然后释放锁,对锁的操作也是有开销的,会有效率上的损失。
单例模式在单例一经创建以后就不会再创建了,无论多少线程在访问已经创建的单例对象时都不会再创建,线程就已经安全了。所以在单例对象创建以后,根本没有必要再去申请锁和释放锁。
将GetInstance()
原本加锁代码放在一个if(m_pInstacne == nullptr)
的代码快中,进行双重检查。
- 当单例对象已经被new出来以后,就不会再进行加锁检查了,可以直接通过
if
进行判断,提高了性能。
new出来对象的释放:
- new出来的单例对象如何释放呢?
一般情况下我们选择不释放,因为全局只有一个单例对象,而且会被一直使用,所以就不用释放,释放了反而后面的使用会出问题。
当进程结束的时候,操作系统会回收该进程的所有资源,包括堆区上的资源。
- 如果就要主动释放呢?在释放的同时将一些信息保存到磁盘。
如上图代码所示,在单例模式的类中创建一个内部类,内部类是外部类的友元。
- 在内部类对象
Gabro
的析构函数中释放new出来的单例对象,并且进行相关的文件操作。 - 内部类对象同样设置成静态成员,在类域外进行定义初始化。
二、类型转换
在C语言中,如果赋值运算符(=)两边的类型不同,或者形参和实参类型不匹配,或者返回值类型和接收值类型不一致,就需要发生类型转换。
C语言中有两种类型转换:
- 隐式类型转换:编译器在编译阶段自动进行,能转就转,不能转就编译失败。
- 显式类型转换:需要用户自己处理。
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;
}
- double d = i是发生了隐式类型转换,将整形转换成了double类型。
隐式类型转换只发生在相近类型,比如整形家族直接,或者这些int,double等表示数值直接的变量类型。
- int address = (int)p是发生了显式类型转换,将int*类型的变量转换为int类型。
显式类型需要用户自己维护,在两种类型没有任何关系的时候需要进行显式类型转换,比如将指针类型转换成普通类型等等。
但是C语言的类型转换存在缺陷:
- 隐式类型转换有些情况下会出现问题,比如数据精度发生丢失(整形提升等)。
- 显式类型转换将所有情况混合在一起,代码不够清晰。
所以C++提出了自己的类型转换风格,但是仍然可以使用C语言的转换风格,因为要兼容C语言。
1、static_cast
C语言的隐式类型转换在C++中就可以使用static_cast来转换,但是不能用于两个不相关的类型进行转换。
double d = 3.14;
int a = static_cast<int>(d);
double类型转int类型,在C语言中是隐式类型转换,在C++中为了更加明确使用了static_cast
。
-
static_cast
后的<>里放要转换的类型,()里放被转换的类型。
如果将static_cast
看成是类模板,<int>
就是在实例化,(d)
就是在拷贝构造,siatic_cast<int>(d)
就是在用d构建一个匿名对象。
2、reinterpret_cast
C语言的显式类型转换在C++中就可以reinterpret_cast,用于将一种类型转换为另一种不同的类型。
int a = 1;
int* pa = &a;
int address = reinterpret_cast<int>(pa);
int*类型转换为int类型,在C语言中是显式类型转换,在C++中为了不混乱使用了reinterpret_cast
。
这里如果使用static_cast
进行类型转换的话会报错,必须使用reinterpret_cast
。
3、 const_cast
用在删除变量的const属性,方便赋值。
const int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;
变量a原本是const属性的,不能被修改,使用了const_cast
以后去除了常量属性,可以修改了,如*p = 3
。
在调试窗口中可以看到,成功修改了原本是const属性的变量a。
const_cast
更多的是一种警示,表示去除了const属性,要谨慎操作。
4 、dynamic_cast
用于将一个父类对象的指针或者引用转换为子类对象的指针或引用(动态转换)。
向上转换:子类对象的指针或引用 → 父类对象的指针或引用。(不发生类型转换,是语法允许的,发生了切片)
向下转换:父类对象的指针或引用 → 子类对象的指针或引用。(用dynamic_cast
转换是安全的)
//父类
class A
{
public:
virtual void f()
{}
int _a = 1;
};
//子类
class B : public A
{
public:
int _b = 2;
};
class A
是父类,class B
是子类,父类中有成员变量int _a
,子类中有成员变量_b
。
在main
函数中,传父类指针&aa
给函数,在函数中将A* pa
父类指针接收该值,然后将其强转为子类指针B*
,使用子类指针访问子类成员,bptr->_b = 4
发生运行时错误。
- 形参
A* pa
是父类指针,接收的也是父类指针,所以强转成子类指针后访问子类成员_b
会发生越界。
如果传的是子类指针就不会报错,因为即使形参是父类指针,强转成子类以后并不会越界。
使用dynamic_cast
将父类指针强转为父类指针。
传父类指针,然后强转为子类指针后,打印出来的结构是nullptr,表示该次转换不能进行。
传子类指针,形参的父类指针接收后再强转为子类,打印出来的结构是强转后的地址,表示该次强转可以成功。
- pa如果指向的是子类对象,那么子类向上转换为父类没有问题。
- pa如果指向的是父类对象,那么父类向下转换为子类是存在越界风险的。
注意:
-
dynamic_cast
只能用于父类含有虚函数的类。 -
dynamic_cast
会先检查是否能转换成功,能成功则转换,不能则返回nullptr。 -
dynamic_cast
是安全的,直接使用C语言的转换方式是不安全的。
C++中的类型转换,尤其是前两种static_cast
和reinterpret_cast
是建议用法,可以采用也可以不采用。const_cast
是一种新用法,但是存在风险,dynamic_cast
是一种安全的类型转换。
三、总结
特殊类的设计中,要掌握好一点,就是只能通过一个接口来获取类,其他的方式不允许,让成员函数或私有或禁掉就可以。特别是单例模式,变成中我们经常用到。
对于类型转换,除了dynamic_cast
是在多态转换中必须使用外,其他三种方式建议使用,可以增加代码的规范性。文章来源:https://www.toymoban.com/news/detail-795368.html
感谢阅读!!!!!!!!!!!!!文章来源地址https://www.toymoban.com/news/detail-795368.html
到了这里,关于C++特殊类设计&&类型转换的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!