IO流与单例模式

单例模式

单例模式是指一个类只能有一个对象。

饿汉模式

在单例模式下，在程序开始（main函数运行前）的时候创建一个对象，这之后就不能再创建这个对象。

class HungryMan
{
public:
	static HungryMan* getinstance()
	{
		return &inst;
	}
private:
	HungryMan()
	{}
	HungryMan(const HungryMan& it) = delete;
	const HungryMan& operator=(const HungryMan& it) = delete;
	static HungryMan inst;//这里是声明，并不是定义，所以可以在类里面包含
	//实际上是全局变量与类封装融合的结果
};

HungryMan HungryMan::inst;//在类外定义

饿汉模式的实现方式较为简单，但存在线程安全(如果没加锁，可能会出现new了几个单例对象出来)，可能导致进程启动慢（main函数启动之前需要创建对象），无法控制单例的初始化顺序（如果不同的单例模式在不同的文件，就无法确认初始化顺序，包括单例之间有可能存在依赖，也可能存在问题）的问题。

懒汉模式

在第一次使用的时候创建。

class LazyMan
{
public:
	static LazyMan* getinstance()
	{
		if (inst == nullptr)
		{
			inst = new LazyMan();
			//new出来的数据是需要释放的，但懒汉对象大部分不需要手动释放
			//但这个对象并不是在程序层面上释放的，而是在系统回收资源的时候释放的
			//那如果我们需要保存一些数据的话，要保证main函数之后要自动调用懒汉类的析构函数
		}
		return inst;
	}

	static void delinstance()
	{
		if (inst == nullptr)
		{
			delete inst;
			inst=nullptr;
		}
	}

private:
	LazyMan()
	{}
	LazyMan(const LazyMan& it) = delete;
	const LazyMan& operator=(const LazyMan& it) = delete;

	static LazyMan* inst;

	class gc
	{
		~gc()
		{
			delinstance();
		}
	};

	static gc delgc;
};

LazyMan* LazyMan::inst = nullptr;

LazyMan::gc LazyMan::delgc;

IO流

c++的IO流

C++系统实现了一个庞大的类库，其中ios为基类，其他类都是直接或间接派生自ios类，c++这个IO流实际上是和C语言保持一致的，比如说istream对标的就是scanf和printf，fstream对标的是fscanf和fprintf，sstream对标的是sscanf和sprintf。

在类型转换中，对于内置类型，相近的类型可以互相转换，其他的可以由构造函数来支持转换，就像自定义类型可以转化为自定义类型，内置类型也可以转换为自定义类型，自定义类型也可以转化为自定义类型。

class tmp
{
public:
	operator int()
	{
		if(/*输入为ctrl+z*/)
		{
			return 0;
		}
		else
		{
			return /*非0*/
		}
	}
};

int main()
{
	tmp t;
	int i = t;
	return 0;
}

标准读写

所以cin可以直接使用while(cin>>tmp)，当输入其他字符，返回值就为真，如果输入ctrl+z，返回值就是假，循环就退出了。
c++默认是兼容C语言的，当c++的cin和C语言的scanf混用的时候，并不会因为缓冲区的问题而导致读取混乱，如果想关掉这种兼容，可以调用下图的函数。

cin.sync_with_stdio(false);
cout.sync_with_stdio(false);

文件读写

在C语言中，fgetc和fputc是用来读单个字符的，fread和fwrite是用来读写文件的，fprintf和fscanf是用来格式化读写的，但这些只能用来对内置类型做操作，在c++里，ifstream是从文件里读，ofstream是写到文件里，可以应付内置类型和自定义类型的输入和输出。
二进制读写：如果要把内存中的数据存到磁盘里，内存中的数据是由类型的，而磁盘没有，我们可以使用二进制读写，也可以使用文本读写。比如说我们要把一个结构体按二进制的形式写到磁盘里：

class A
{
private:
	int a;
	char b;
	string c;
};


class Bin
{
public:
	Bin(const char* filename="./info.bin")
		:_filename(filename)
	{}

	void Write()
	{
		ofstream ofs(_filename, ios_base::out | ios_base::binary);
		A data;
		ofs.write((const char*)&data, sizeof(data));
	}

	void Read(A & rA)
	{
		ifstream ifs(_filename, ios_base::in | ios_base::binary);
		ifs.read((char*)&rA, sizeof(rA));
	}

private:
	string _filename;
};

我们可以用read再次读取，但这样是把数据原封不动的读回来，包括地址，但这样在同一个进程就会发生浅拷贝问题，析构两次，而如果是不同的进程读取，就会出现野指针问题，因为到后来的进程读取的时候，前面进程的空间早就销毁了，根据文件拷贝回来的地址就是一个野指针，所以只要是容器都要注意不能用二进制进行读取，因为容器底层都相对复杂。
文本读写：如果要正常读写到文件里和从文件里读出来，都要和字符串相互转化。但这样转化太麻烦，所以在C语言中，我们可以使用sscanf和sprintf转化完后用fwrite和fread写到文件里和读取。而在c++中重载了流插入和流提取，所以也不需要自己去做转换。

class Text
{
public:
	Text(const char* filename = "./info.text")
		:_filename(filename)
	{}

	void Read(A& rA)
	{
		ifstream ifs(_filename);
		ifs >> rA._a >> rA._b >> rA._c;
	}

	void Write()
	{
		A data(1, 'a', "hello world");
		ofstream ofs(_filename);
		ofs << data._a;
		ofs << data._b;
		ofs << data._c;//可以使用getline
	}
private:
	string _filename;
};

stringstream

自定义类型不方便转为字符串，所以可以调用stringstream。

class A
{
public:
	A(int a=0,char b='\0', string c="")
		:_a(a)
		,_b(b)
		,_c(c)
	{}
	int _a;
	char _b;
	string _c;
};


ostream& operator << (ostream & os, A aa)//必要手动写格式
{
	os << aa._a << '/' << aa._b << '/' << aa._c;
	return os;
}

int main()
{
	A tmp(20, 'a', "hello world");
	ostringstream oss;
	oss << tmp;

	string out = oss.str();
	cout << out << endl;
	return 0;
}

但stringstream并不会用于比较复杂的情景，比较复杂的情景可以使用json。

class Date
{
public:
	Date(int _year,int _month,int _day)
		:year(_year)
		,month(_month)
		,day(_day)
	{}
	int year;
	int month;
	int day;
};
istream& operator>>(istream& is, Date& d)
{
	is >> d.year >> d.month >> d.day;
	return is;
}

ostream& operator<<(ostream& os, Date& d)
{
	os << d.year <<' ' << d.month<<' ' << d.day << ' ';
	return os;
}
class Parent
{
public:
	Parent(int a1,char b1,Date c1)
		:a(a1)
		,b(b1)
		,c(c1)
	{}
	int a;
	char b;
	Date c;
};


ostream& operator<<(ostream& os, Parent& p)
{
	os << p.a <<' ' << p.b<<' ' << p.c << ' ';
	return os;
}

istream& operator>>(istream& is, Parent& p)
{
	is >> p.a >> p.b >> p.c;
	return is;
}

int main()
{
	Date d1(2025, 8, 16);
	Parent p1(10, 'a', d1);
	ostringstream os;
	os << p1;

	Date d2(2024, 9, 18);
	Parent p2(20, 'b', d2);
	istringstream is(os.str());
	is >> p2;

	return 0;
}