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<iostream>
#include<string>
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
执行此命令前，确保在当前目录下有in.txt文件，并在文件中写入一个字符串
执行后会发现窗口上输出了，文件里面的字符串和“学习C++”，这是因为，我们使用了"<in.txt"对程序中的 cin 输入流做了重定向。
继续测试：
~:demo.exe <in.txt >out.txt
执行后会发现，控制台没有任何输出。这是因为，我们使用了"<in.txt"对程序中的 cin 输入流做了重定向，同时还用 ">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 <iomanip>提供的控制符，进行输入输出格式控制
| 控制符 | 作用 |
|---|---|
| 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++标准库中的<sstream>提供了比ANSI C的<stdio.h>更高级的一些功能，即单纯性、类型安全和可扩展性。
在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. 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。
- 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。
五， C++中使用异常时应注意的问题
任何事情都是两面性的，异常有好处就有坏处。如果在你的代码中使用异常，那么需要注意以下事项:
1. 性能问题。这个一般不会成为瓶颈，但是如果你编写的是高性能或者实时性要求比较强的软件，就需要考虑了。
2. 指针和动态分配导致的内存回收问题：动态内存不会自动回收，如果遇到异常就需要考虑是否正确的回收了内存。
- 函数的异常抛出列表：如果没有写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 语句，用于捕获不同类型的异常
捕获异常时的注意事项：
- catch的匹配过程是找最先匹配的，不是最佳匹配。
- 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风格字符串）的值，描述异常信息。
下表是对上面层次结构中出现的每个异常的说明：
九、编写自己的异常类
- 为什么要编写自己的异常类？
① 标准库中的异常是有限的；
② 在自己的异常类中，可以添加自己的信息。（标准库中的异常类值允许设置一个用来描述异常的字符串）。 - 如何编写自己的异常类？
① 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。
② 当继承标准异常类时，应该重载父类的what函数和虚析构函数。
③ 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。
示例：
#include <iostream>
#include <exception>
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. 编写的供别人调用的程序库，不应该结束程序，而应该通过抛出异常，让调用者决定如何处理（因为调用者必须要处理抛出的异常）。
扫一扫
606
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
