特殊类的设计与类型转换

🕗 发布于 2024-09-22 04:17 c++

特殊类的设计

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

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

C++98

C++98是怎么设计的呢？

class CopyBan
{
public:
CopyBan() = default;
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
};

（将拷贝构造与赋值重载函数封装为私有）

原因：

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

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

C++11

C++11之后新增了delete 关键字

class CopyBan
{
public:
CopyBan() = default;
CopyBan(const CopyBan&) = delete;
CopyBan& operator=(const CopyBan&) = delete;
};

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

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

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

class HeapOnly
{
public:
static HeapOnly* Creatobj()
{
return new HeapOnly;
}

private:
HeapOnly()
{

}

HeapOnly(const HeapOnly&) = delete;
};

int main()
{
//HeapOnly();
//static HeapOnly hp1;

HeapOnly* hp2 = HeapOnly::Creatobj();
//HeapOnly hp3(*hp2);
return 0;
}

还有一种比较另类的方法，把析构函数给私有化。

class HeapOnly
{
public:
void destroy()
{
delete this;
}

private:
~HeapOnly()
{

}
};

int main()
{
//HeapOnly();
//static HeapOnly hp1;

HeapOnly* hp2 = new HeapOnly;
hp2->destroy();
//HeapOnly* hp2 = HeapOnly::Creatobj();
//HeapOnly hp3(*hp2);
return 0;
}

但是我们就要用写一个成员函数来调用析构函数。

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

先看下面这种写法有什么问题没有？

class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
private:
StackOnly()
{

}
void* operator new(size_t size) = delete;

private:
    int _a = 1;
};

下面这种写法虽然不可以再堆上创建对象了，但是可以在静态区创建对象。有点封不死。

我们可以像下面这样写呢?：

class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}

StackOnly(StackOnly&& s)
{

}

StackOnly(const StackOnly& s) = delete;
private:
StackOnly()
{

}
};

所以相对而言还是第一种方法更好一点。

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

C++98方式：

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};

C++11：

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

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

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

设计模式：

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

饿汉模式

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

class InfoMgr
{
public:
static InfoMgr& GetInstance()
{
return _ins;
}

private:
InfoMgr()
{

}

InfoMgr(const InfoMgr& i) = delete;
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t buffsize = 1024 * 1024;
static InfoMgr _ins;
};

InfoMgr InfoMgr::_ins;

int main()
{
InfoMgr& Im1 = InfoMgr::GetInstance();
}

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

懒汉模式

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

class InfoMgr
{
public:
static InfoMgr& GetInstance()
{
if (_pins == nullptr)
{
_pins = new InfoMgr;
}
return *_pins;
}

private:
InfoMgr()
{

}

InfoMgr(const InfoMgr& i) = delete;
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t buffsize = 1024 * 1024;
static InfoMgr* _pins;
};

InfoMgr* InfoMgr::_pins = nullptr;

int main()
{
InfoMgr& Im1 = InfoMgr::GetInstance();
}

类型转换

1. C语言中的类型转换

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

1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败

2. 显式类型转化：需要用户自己处理

隐式类型转化：整形与整形之间，整形与浮点数之间。

显式类型转化：整形与指针，指针与指针之间。

void Test()
{
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);
}

内置类型与自定义类型转换

内置类型是可以隐式转换为自定义类型但需要借助成员函数。

class A
{
public:
A(int a)
:_a1(a)
,_a2(a)
{}

A(int a, int b)
:_a1(a)
, _a2(b)
{}

private:

int _a1;
int _a2;
};

int main()
{
    //单参数
A aa1 = 1;
    //多参数
A aa2 = {1, 2};
}

不想隐式类型转换可以加个explicit 关键字

自定义类型如何转换内置类型：


int operator()()
{
return _a1 + _a2;
}

这种写法是错误的因为 operator ()被仿函数占用了，所以C++就有一种特殊的写法。

class A
{
public:
A(int a)
:_a1(a)
,_a2(a)
{}

A(int a, int b)
:_a1(a)
, _a2(b)
{}

operator int()
{
return _a1 + _a2;
}

private:

int _a1;
int _a2;
};

同样加上explicit 就不能隐式类型转换。

但是还是可以显式类型转换

自定义类型转换自定义类型

两个没有关联的类型是不能进行转换的。（需要对应构造函数的支持）

2.C++强制类型转换

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

2.1 static_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关的类型进行转换。

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

2.2 reinterpret_cast

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型

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

2.3 const_cast

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

const_cast：对应的是强制类型转换中的去掉const 属性

可以看到用强制类型转换也是可以的但是C++为了规范一下增加了const_cast ，我们通过调试可以发现a1 在监视窗口已经变成了2，但是打印出来还是3。

这是因为a1 被直接替换成了常量。

所以上面场景还是建议加上 volatile 关键字，表示告诉编译器再取这个值的时候，不要替换成常量或者去寄存器取值，而是直接去内存中取。

2.4 dynamic_cast

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

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

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

注意：

1. dynamic_cast只能用于父类含有虚函数的类

2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

dynamic_cast为什么要先检查是否能转换成功呢？

我们来看下面场景：

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

int _a = 1;
};
class B : public A
{
public:
int _b = 2;
};

void fun(A* pa)
{
// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
B* pb1 = dynamic_cast<B*>(pa);

if (pb1)
{
cout << pb1->_a << endl;
cout << pb1->_b << endl;
}
else
{
cout << "转换失败"<<endl;
}
}

int main()
{
A a;
B b;
fun(&a);
fun(&b);
return 0;
}

可以看到_b 是随机值，如果对_b 进行写操作就会报错。所以指向父类向下转换是有越界访问风险的，指向子类转换时安全。

为什么 dynamic_cast只能用于父类含有虚函数的类

因为dynamic_cast 的本质就是在虚表中加入一些标识，然后检查标识。

3. RTTI

RTTI：Run-time Type identification的简称，即：运行时类型识别。C++通过以下方式来支持RTTI：

1. typeid运算符

2. dynamic_cast运算符

3. decltype

感谢大家的观看！

原文地址：https://blog.csdn.net/2301_80468112/article/details/142307030

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：电子元器件之MOS管，附上几个常用MOS管电路和仿真。
下一篇：redisson实现分布式锁

【网络安全】Cookie SameSite属性
严格限制可能会影响用户体验，例如，当用户点击 GitHub 链接时，无法保持登录状态，因为此时会丢失 GitHub 的 Cookie。当浏览器加载该图片时，它会向 A.com 发送带有 Cookie
阅读更多2024-11-16
【C语言】实现二维数组按行排序
【C语言】实现二维数组按行排序
阅读更多2024-11-16
NLP开发常见问题
NLP开发常见问题
阅读更多2024-11-16
在spring boot工程中使用Filter时，@WebFilter 注解不生效的问题分析和解决方案
如果要使用@WebFilter进行过滤路径的配置，则需要在启动类中添加@ServletComponentScan注解启用Servlet容器扫描@WebFilter注解，并删除Filter类中的@Com
阅读更多2024-11-16
天天学编程Day16
在 C++ 中，常量表达式（Constant Expression）是指在编译期就能计算出结果的表达式。其结果在程序运行过程中是不可改变的，并且这个结果必须是编译时常量，例如整数常量、枚举常量、用常量
阅读更多2024-11-16
消失的数字（c语言实现）
方法一我们使用异或操作符实现。介绍一下^操作符性质就是首先0^a=a；a^a=0;然后异或操作符还满足交换律。比如a ^ b ^ c ^a= a ^ a ^b ^c;我们可以通过这样的性质实现这个代
阅读更多2024-11-16
机器学习——期末复习重点题归纳
机器学习期末复习
阅读更多2024-11-16
opencv kdtree & pcl kdtree 效率对比
由于项目中以一个环节需要使用kdtree ,对性能要求比较严苛，所以看看那个kdtree效率高一些。对比了opencv和pcl。
阅读更多2024-11-16
Qt 5.6.3 手动配置 mingw 环境
手动设置 qt mingw 编译环境
阅读更多2024-11-16
IntelliJ IDEA 2024.3（Ultimate Edition）免费化教学
一款由 JetBrains 公司开发的集成开发环境 (Integrated Development Environment, IDE)，主要用于 Java 语言的软件开发，但它也支持其他多种编程语言和
阅读更多2024-11-16

特殊类的设计与类型转换