IO流

I/O流

①在C++的标准库中，将用于进行数据输入输出的类统称为”流类“。cin是流类istream的对象，cout是流类ostream的对象。要使用流类，需要在程序中包含iostream头文件

② 对系统指定的标准设备的输入和输出。即从键盘输入数据，输出到显示器屏幕。这种输入输出称为标准的输入输出，简称标准I/O。

​③以外存磁盘文件为对象进行输入和输出，即从磁盘文件输入数据，数据输出到磁盘文件。以外存文件为对象的输入输出称为文件的输入输出，简称文件I/O。

​④对内存中指定的空间进行输入和输出。通常指定一个字符数组作为存储空间(实际上可以利用该空间存储任何信息)。这种输入和输出称为字符串输入输出，简称串I/O。

输入输出流

ostream头文件中定义了四个标准流对象，它们是cin、cout、cerr和clog。

对象	功能	特点
cin	标准输入	从键盘读取，可以重定向为从文件读取
cout	标准输出	输出到屏幕，可以重定向为向文件写入
cerr	标准错误	必须输出到屏幕，不可以重定向为向文件写入
clog	标准错误	输出到屏幕，可以重定向为向文件写入

所谓重定向，就是将输入的源或输出的目的地改变。例如，cout本来是输出到屏幕的，但是经过重定向，本该输出到屏幕上的东西就可以被输出到文

通过控制台实现重定向

//demo.cpp
#include
#include
using namespcae std;
int main()
{
    string name;
    cin>>name;		
    cout<<name<<"学习C++";
    return 0;
}

程序运行之后，会生成一个demo.exe可执行文件，该执行文件可以双击指针，也可以在控制台执行。列如，打开控制台(Windows 系统下指的是 CMD命令行窗口，Linux 系统下指的是 Shell 终端），并输入如下指令：

~:demo.exe
愫白
愫白学习C++

可以看到，demo.ext 成功被执行，但程序中的 cin 和 cout 并没有被重定向，因此这里仍需要我们手动输入测试数据。

在此基础上，继续在控制台执行如下指令：

~:demo.exe 

执行此命令前，确保在当前目录下有in.txt文件，并在文件中写入一个字符串

执行后会发现窗口上输出了，文件里面的字符串和“学习C++”，这是因为，我们使用了"

继续测试：

~:demo.exe out.txt

执行后会发现，控制台没有任何输出。这是因为，我们使用了"out.txt"对程序中的 cout 输出流做了重定向。

标准输入流常见API

• cin.get()

int cin.get();													//读取一个字符
istream& cin.get(char* _Str, streamsize _Count,char _Delim);	//读取字符串，超过count大小或者遇到字符delim时停止

• cin.getline()

istream& getline(char* _Str, streamsize _Count);
istream& getline(char* _Str, streamsize _Count,char _Delim);

• 用cin>>str输入字符串时，遇到空格会截断，所以最好用cin.getline()

标准输出流格式控制两种方式

• 通过流成员函数进行输入输出格式控制

//gobal 表示该设置会全局生效(会影响到后面的输出)
	cout.width(20);				//设置内容所占宽度，默认右对齐，空格填充
	cout.fill('*');				//设置填充字符，把上面的空格替换成指定字符	global
	cout.setf(ios::left);		//设置对齐方式								global
	cout.setf(ios::scientific);	//用科学计数法显示浮点数				    global
	cout << 1.2 << endl;

	cout.width(50);
	cout.unsetf(ios::scientific);	//取消科学计数法显示浮点数				global
	cout << 3.14 << endl;

	cout.precision(3);				//设置浮点数精度，包括整数位			global
	cout << 1.23456 << endl;
	

	cout.setf(ios::showbase | ios::uppercase);	//显示前缀并用大写的方式显示十六进制前缀 global
	cout << oct << 520 << endl;		//以八进制显示整数		global
	cout << dec << 520 << endl;		//以十进制显示整数		global
	cout << hex << 520 << endl;		//以十六进制显示整数	global


	cout.setf(ios::showpos);				//强制显示符号(+ -)
	cout.setf(ios::dec);					//设置十进制显示整数
	cout << 666 << endl;

有些设置会全局生效，所以如果在一次输出过程中需要混杂多种格式，使用ios_base的成员函数来处理就显得很不方便。所以提供了iomanip库可以满足这种使用方式。

• 通过#include 提供的控制符，进行输入输出格式控制

控制符	作用
setbase(n)	设置整数为n进制(n=8,10,16)
setfill(n)	设置填充字符
setprecision(n)	设置浮点数精度
setw(n)	设置内容宽度
setiosflags(ios::scientific)	设置浮点数以科学计数法显示
setiosflags(ios::left)	输出左对齐

cout <<setw(30) <<setfill('*')<< setiosflags(ios::left) << 520 << endl;

上述接口与ios_base的格式控制成员是对应的，可以二者配合进行输出格式的精准控制。其中的精度控制默认是6位有效数字，科学计数法中的指数部分e为默认小写。setw设置的宽度如果小于字段宽度会失效

字符串流

C++标准库中的提供了比ANSI C的更高级的一些功能，即单纯性、类型安全和可扩展性。

在C语言我们学习了sprintf和sscanf对字符串和其他类型进行转换，但是使用时，一旦把格式控制符写错，程序将会崩溃，在调用完sprintf()后包含了一个不确定的字符串。要是能自动推导出正确的类型，那不是更好吗？

int num = 256;
char str[128] = "";
sprintf(str, "%s", num);	//此处应为%d

C++strstream实现转换

int num = 256;
char str[128] = "";
	
stringstream stream(str);
stream <<num;
stream >> str;

cout << str << endl;

值得注意的是使用同一流对象进行多次转换时，必须调用clear()成员

stringstream stream;

int number;
stream << "736666";
stream >> number;
cout << number << endl;

stream.clear();				在进行多次转换前，必须清除stream

char str[128] = "";
stream << 3.14;
stream >> str;
cout << str << endl;

文件流

C++提供文件流fstream用来处理文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oWne6n57-1615648506500)(assets/image-20210313143331185.png)]

在从文件读取信息或者向文件写入信息之前，必须先打开文件。

• ofstream 用来打开文件进行写操作
• ifstream 用来打开文件进行读操作
• fstream 支持文件的读和写操作

打开文件

• 通过构造函数打开

• 通过成员函数open打开

  void open(const char *filename, ios::openmode mode);

  • filename 要打开的文件名

  • mode 操作模式

  方式	作用
  ios::in	以读方式打开文件
  ios::out	以写的方式打开文件，如果已有此名字的文件，则将其原有内容全部清除
  ios::app	以写的方式打开文件，写入的数据添加在文件末尾
  ios::ate	打开一个已有的文件，文件指针指向文件末尾
  ios::trunc	打开一个文件，如果文件已存在，则删除其中全部数据，如文件不存在，则建立新文件。如已指定ios:out方式，而未指定ios: :app ,ios:.ate ,ios: :in，则同时默认此方式
  ios::binary	以二进制方式打开文件，默认为ASCII方式打开

| ios::nocreate | 打开一个已有的文件，如果文件不存在，则打开失败。nocreate是不创建新文件 |
| ios::noreplace | 如果文件不存在在则建立新文件，如果文件已存在则操作失败 |
| ios::in | ios::out | 以读和写的方式打开文件 |
| ios::out | ios::binary | 以二进制写的方式打开文件 |
| ios::in | ios::binary | 以二进制读的方式打开文件 |

判断是否打开成功

• 成员函数:is_open()
• 运算符重载:!file

fstream file("./maye.txt", ios::in | ios::out);
if (!file || !file.is_open())
{
	cerr << "文件打开失败" << endl;
}
file.close();

• 关闭文件：close()

读写文件

• 两种主要方式读写文件
  • 流运算符 << >>
  • 成员函数 write read

/*文本文件读写*/
void asciiReadWrite(char* destFileName, char* srcFileName)
{
	fstream fsrc(srcFileName, ios::in);
	fstream fdest(destFileName, ios::out);

	//流运算符方式  会忽略空格，换行
	/*while (!fsrc.eof())
	{
		char ch;		//char str[1024];
		fsrc >> ch;
		fdest << ch;
		cnt++;
	}*/
	//成员函数方式 会保留空格，换行
	/*while (!fsrc.eof())
	{
		char ch;
		fsrc.get(ch);
		fdest.put(ch);
		cnt++;
	}*/

	/*while (!fsrc.eof())
	{
		char str[1024] = "";
		fsrc.read(str, 1024);
		fdest.write(str, 1024);
	}*/


	fsrc.close();
	fdest.close();
}
/*二进制文件读写*/
void binReadWrite(char* destFileName, char* srcFileName)
{
	fstream fsrc(srcFileName, ios::in | ios::binary);
	fstream fdest(destFileName, ios::out | ios::binary);


	//成员函数方式 会保留空格，换行
	/*while (!fsrc.eof())
	{
		char ch;
		fsrc.get(ch);
		fdest.put(ch);
	}*/

	/*while (!fsrc.eof())
	{
		char str[1024] = "";
		fsrc.read(str, 1024);
		fdest.write(str, 1024);
	}*/


	fsrc.close();
	fdest.close();
}

文件位置指针

文件流还提供了用于重新定位文件位置指针的成员函数。

//移动ifstream的位置指针
istream&  seekg(long int _Pos);
istream&  seekg(long int _Pos,ios_base::seekdir _Way);
//移动ofstream的位置指针
istream&  seekg(long int _Pos);
istream&  seekg(long int _Pos,ios_base::seekdir _Way);

• _Pos:偏移量
• _Way:从哪里开始偏移
  • ios::beg 默认的，从流的开头开始
  • ios::cur 从流的当前位置开始
  • ios::end 从流的末尾开始定位

//件内容  abcdefghigk
fstream fr("./code.txt", ios::in);
if (!fr)
{
	cerr << "文件打开失败" << endl;
}

fr.seekg(3);	
char ch = fr.get();
cout << ch << endl;	//  输出 d

fr.seekg(0, ios::beg);
cout << (char)fr.get() << endl;	//输出 a

fr.close();

异常处理

一，什么是异常处理

一句话：异常处理就是处理程序中的错误，比如尝试除以零的操作。

二，为什么需要异常，以及异常处理的基本思想

C++之父Bjarne Stroustrup在《The C++ Programming Language》中讲到：一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们（因为和用户具体的应用有关）；另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生（如果能检测，就可以再用户的代码里处理了，不用留给库去发现）。

​ Bjarne Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或者间接）调用者能够处理这个问题。

​ 也就是《C++ primer》中说的：将问题检测和问题处理相分离。

​ 一种思想：在所有支持异常处理的编程语言中，要认识到的一个思想：在异常处理过程中，由问题检测代码可以抛出一个对象给问题处理代码，通过这个对象的类型和内容，实际上完成了两个部分的通信，通信的内容是“出现了什么错误”。当然，各种语言对异常的具体实现有着或多或少的区别，但是这个通信的思想是不变的。

三，异常出现之前处理错误的方式

在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。当然C++中仍然是可以用这两种方法的。

​ 这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。

​ 还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。

四，异常为什么好

优点有以下几点：

​ 1. 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。

​ 2. 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。

​ 3. 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。

4. 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。

五， C++中使用异常时应注意的问题

任何事情都是两面性的，异常有好处就有坏处。如果在你的代码中使用异常，那么需要注意以下事项:

​ 1. 性能问题。这个一般不会成为瓶颈，但是如果你编写的是高性能或者实时性要求比较强的软件，就需要考虑了。

​ 2. 指针和动态分配导致的内存回收问题：动态内存不会自动回收，如果遇到异常就需要考虑是否正确的回收了内存。

3. 函数的异常抛出列表：如果没有写noexcept，意味着你可以抛出任何异常。

六，异常基本语法

很简单，抛出一场用throw，捕获用try…catch

• throw: 当问题出现时，程序会抛出一个异常。
• catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。
• try: try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。
• **noexcept：**用于声明函数不抛出异常，如果函数抛了异常，则直接中断，不能被捕获

使用 try…catch 语句的语法如下所示：

try
{
   // 保护代码
}catch( ExceptionName e1 )
{
   // catch 块
}catch( ExceptionName e2 )
{
   // catch 块
}catch( ExceptionName eN )
{
   // catch 块
}

如果 try 块在不同的情境下会抛出不同的异常，这个时候可以尝试罗列多个 catch 语句，用于捕获不同类型的异常

捕获异常时的注意事项：

1. catch的匹配过程是找最先匹配的，不是最佳匹配。
2. catch的匹配过程中，对类型的要求比较严格。不允许标准算术转换和类类型的转换。（类类型的转化包括两种：通过构造函数的隐式类型转化和通过转化操作符的类型转化）。

七，异常之栈解旋

异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。

析构的顺序与构造的顺序相反，这一过程称为栈的解旋(unwinding).

struct Maker
{
	Maker()
	{
		cout << "Maker() 构造函数" << endl;
	}
	Maker(const Maker& other)
	{
		cout << "Maker(Maker&) 拷贝构造函数" << endl;
	}
	~Maker()
	{
		cout << "~Maker() 析构函数" << endl;
	}
};
void fun()
{
	Maker m;
	cout << "--------" << endl;
	throw m;
	cout << "fun__end" << endl;
}
int main()
{
	try
	{
		fun();
	}
	catch (Maker & m)
	{
		cout << "收到Maker异常" << endl;
	}
}

八，C++ 标准的异常

C++ 提供了一系列标准的异常，定义在 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kcDnsqmB-1615648506502)(assets/image-20210313190946638.png)]

每个类所在的头文件在图下方标识出来

标准异常类的成员：
① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。
② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述；
③ 所有的异常类都有一个what()方法，返回const char* 类型（C风格字符串）的值，描述异常信息。

下表是对上面层次结构中出现的每个异常的说明：

异常	描述
std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过 new 抛出。
std::bad_cast	该异常可以通过 dynamic_cast 抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过 typeid 抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument	当使用了无效的参数时，会抛出该异常。
std::length_error	当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
std::overflow_error	当发生数学上溢时，会抛出该异常。
std::range_error	当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error	当发生数学下溢时，会抛出该异常。

九、编写自己的异常类

• 为什么要编写自己的异常类？
  ① 标准库中的异常是有限的；
  ② 在自己的异常类中，可以添加自己的信息。（标准库中的异常类值允许设置一个用来描述异常的字符串）。
• 如何编写自己的异常类？
  ① 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。
  ② 当继承标准异常类时，应该重载父类的what函数和虚析构函数。
  ③ 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。

示例：

#include 
#include 
using namespace std;
 //第一种
class Out_Range : public exception
{
public:
	explicit Out_Range(const string& _Message) : exception(_Message.c_str()) {}
	explicit Out_Range(const char* _Message) : exception(_Message) {}
};
//第二种
struct Exce :public exception
{
	const char* what() const override
	{
		return "Exce";
	}
};
 
void foo(int arr[], int len)
{
	int i = -1;
	if (i<0 || i>=len)
	{
		throw Out_Range("数组越界啦~");
	}
	cout << arr[i] << endl;
}

int main()
{
	int arr[3] = { 0 };
	try
	{
		foo(arr, 3);
	}
	catch (Out_Range& e)		//自定义错误
	{
		cout << "Out_Range& e   " << e.what() << endl;
	}
	catch (std::exception& e)	//其他错误
	{
		cout <<"std::exception& e   "<<e.what()<< endl;
	}
	return 0;
}

十，来自C++之父Bjarne Stroustrup的建议

节选自《The C++ Programming Language》 ——C++之父Bjarne Stroustrup
1. 当局部的控制能够处理时，不要使用异常；
2.使用“资源分配即初始化”技术去管理资源；
3. 尽量少用try-catch语句块，而是使用“资源分配即初始化”技术。
4. 如果构造函数内发生错误，通过抛出异常来指明。
5. 避免在析构函数中抛出异常。
6. 保持普通程序代码和异常处理代码分开。
7. 小心通过new分配的内存在发生异常时，可能造成内存泄露。
8. 如果一个函数可能抛出某种异常，那么我们调用它时，就要假定它一定会抛出该异常，即要进行处理。
9. 要记住，不是所有的异常都继承自exception类。
;
}
return 0;
}

##### 十，来自C++之父Bjarne Stroustrup的建议

  节选自《The C++ Programming Language》 ——C++之父Bjarne Stroustrup 
     	1. 当局部的控制能够处理时，不要使用异常； 
          	2.使用“资源分配即初始化”技术去管理资源； 
          	3. 尽量少用try-catch语句块，而是使用“资源分配即初始化”技术。 
               	4.  如果构造函数内发生错误，通过抛出异常来指明。 
                    	5. 避免在析构函数中抛出异常。 
                         	6.  保持普通程序代码和异常处理代码分开。 
                              	7. 小心通过new分配的内存在发生异常时，可能造成内存泄露。 
                                   	8.  如果一个函数可能抛出某种异常，那么我们调用它时，就要假定它一定会抛出该异常，即要进行处理。 
                                        	9. 要记住，不是所有的异常都继承自exception类。 
                                             	10. 编写的供别人调用的程序库，不应该结束程序，而应该通过抛出异常，让调用者决定如何处理（因为调用者必须要处理抛出的异常）。