C++：特殊类的设计、类型转化、IO流

---

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

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

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

实现方式：

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

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

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

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;
 void operator delete(void* p) = delete;
private:
 StackOnly()  
 :_a(0)
 {}
private:
 int _a;
};

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

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

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

5.1 饿汉模式

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

5.2 懒汉模式

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

6.C++的4个类型转换

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

6.1 static_cast

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

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

6.2 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;
}

6.3 const_cast

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

int main()
{
	volatile const int a = 1;//显示2
	const int a = 1;//显示1
	// a++;
	int x = 0;

	cout << &a << endl;
	cout << &x << endl;

	//int* ptr = (int*)&a;
	int* ptr = const_cast<int*>(&a);
	(*ptr)++;

	cout << *ptr << endl;
	cout << a << endl;
	return 0;
}

提示：用volatile关键字优化，就可以解决这个问题。所以用了const_cast就需要注意需不需要用volatile！

6.4 dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意：

1. dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先在这里插入代码片检查是否能转换成功，能成功则转换，不能则返回0

#include<iostream>
using namespace std;

class A//A父类
{
public:
	virtual void f() {}  //没有虚函数会报错，dynamic_cast只能用于父类含有虚函数的类(多态类型)

	int _a1 = 1;
};

class B : public A//B子类
{
public:
	int _b1 = 1;
};

//void fun(A* pa)
//{
//	// 无差别转换，存在一定风险
//	B* pb = (B*)pa;
//	cout << pb << endl;
//	pb->_b1++;   //fun(&a)崩溃，因为其没有_b1部分
//}

void fun(A* pa)
{
	// pa指向B对象，转换成功
	// pa指向A对象，转换失败，返回空

	B* pb = dynamic_cast<B*>(pa);//为了解决上述问题，C++设立一款动态转化
	if (pb)
	{
		cout << pb << endl;
		pb->_b1++;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

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

	return 0;
}

7.IO流

C++标准库提供了4个全局流对象cin、cout、cerr、clog，使用cout进行标准输出，即数据从内存流向控制台(显示器)。使用cin进行标准输入即数据通过键盘输入到程序中，同时C++标准库还提供了cerr用来进行标准错误的输出，以及clog进行日志的输出，从上图可以看出，cout、cerr、clog是ostream类的三个不同的对象，因此这三个对象现在基本没有区别，只是应用场景不同。

// 单个元素循环输入
while(cin>>a)
{
    // ...
}
// 多个元素循环输入
while(c>>a>>b>>c)
{
    // ...
}
// 整行接收
while(cin>>str)
{
    // ...
}

IO效率

printf和scanf的效率比cin，cout高，所以一般推荐printf和scanf。
如果需要用cin，cout可用如下代码增加效率

    // 在io需求比较高的地方，如部分大量输入的竞赛题中，加上以下3行代码
	// 可以提高C++IO效率
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

文件IO与C的fwritr，fread等函数类似，这里就不做过多说明
具体可参考如下网站
https://legacy.cplusplus.com/reference/ios/