【本节目标】
1. C语言的输入与输出
2. 流是什么
3. C++IO流
4. stringstream的简单介绍
1. C语言的输入与输出
C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。
⭐scanf(): 从标准输入设备(键盘)读取数据,并将值存放在变量中。
⭐printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。 注意宽度输出和精度输出控制。
C语言借助了相应的缓冲区来进行输入与输出。如下图所示:
对输入输出缓冲区的理解:
- 1.可以屏蔽掉低级I/O的实现,低级I/O的实现依赖操作系统本身内核的实现,所以如果能够屏 蔽这部分的差异,可以很容易写出可移植的程序。
- 2.可以使用这部分的内容实现“行”读取的行为,对于计算机而言是没有“行”这个概念,有了这 部分,就可以定义“行”的概念,然后解析缓冲区的内容,返回一个“行”。
2. 流是什么
“流”即是流动的意思,是物质从一处向另一处流动的过程,是对一种有序连续且具有方向性的数据( 其单位可以是bit,byte,packet )的抽象描述。
⭐C++流是指信息从外部输入设备(如键盘)向计算机内部(如内存)输入和从内存向外部输出设备(显示器)输出的过程。这种输入输出的过程被形象的比喻为“流”。
它的特性是:有序连续、具有方向性
为了实现这种流动,C++定义了I/O标准类库,这些每个类都称为流/流类,用以完成某方面的功能
3. C++IO流
C++系统实现了一个庞大的类库,其中ios为基类,其他类都是直接或间接派生自ios类
3.1 C++标准IO流
C++标准库提供了4个全局流对象cin、cout、cerr、clog
⭐使用cout进行标准输出,即数据从内存流向控制台(显示器)。
⭐使用cin进行标准输入即数据通过键盘输入到程序中,
⭐使用cerr用来进行标准错误的输出,
⭐使用clog进行日志的输出,
从上图可以看出cout、 cerr、clog是ostream类的三个不同的对象,因此这三个对象现在基本没有区别,只是应用场景不同。
在使用时候必须要包含文件并引入std标准命名空间。
注意:
1. cin为缓冲流。键盘输入的数据保存在缓冲区中,当要提取时,是从缓冲区中拿。如果一次输 入过多,会留在那儿慢慢用,如果输入错了,必须在回车之前修改,如果回车键按下就无法挽回了。只有把输入缓冲区中的数据取完后,才要求输入新的数据。
2. 输入的数据类型必须与要提取的数据类型一致,否则出错。出错只是在流的状态字state中对 应位置位(置1),程序继续。
3. 空格和回车都可以作为数据之间的分格符,所以多个数据可以在一行输入,也可以分行输 入。但如果是字符型和字符串,则空格(ASCII码为32)无法用cin输入,字符串中也不能有空格。回车符也无法读入。
4. cin和cout可以直接输入和输出内置类型数据,原因:标准库已经将所有内置类型的输入和输出全部重载了:
5. 对于自定义类型,如果要支持cin和cout的标准输入输出,需要对<<和>>进行重载。
6. 在线OJ中的输入和输出:
- 对于IO类型的算法,一般都需要循环输入:
- 输出:严格按照题目的要求进行,多一个少一个空格都不行。
- 连续输入时,vs系列编译器下在输入ctrl+Z时结束
// 单个元素循环输入
while (cin >> a)
{
// ...
}
// 多个元素循环输入
while (cin >> a >> b >> c)
{
// ...
}
// 整行接收
while (cin >> str)
{
// ...
}
随后我们再来看一下operator bool的返回值,我们会发现这里如果没成功就会设置一些标记位,那我们来看看有一些什么样的标记位
在 C++ 中,ios_base 类为输入/输出流提供了一组错误状态位。这四个错误状态位是:
-
eofbit (end-of-file bit):当到达文件结尾时设置。例如,当从文件中读取数据时,如果已经读取了所有数据,eofbit 将被设置为 true。
-
failbit (failure bit):当遇到非致命错误时设置。例如,如果尝试从文件中读取数据,但文件无法打开,failbit 将被设置为 true。
-
badbit (bad bit):当遇到致命错误时设置。例如,如果尝试写入到只读文件中,badbit 将被设置为 true。
-
goodbit:当没有错误时设置。当 eofbit、failbit 和 badbit 都没有被设置时,goodbit 被设置为 true。
它们之间的区别在于错误的严重程度:
-
eofbit 代表正常操作的结束,并非错误。
-
failbit 代表非致命错误,通常可以恢复。
-
badbit 代表致命错误,通常无法恢复。
我们来演示一下:
// 流的默认标志都是goodbit
int main()
{
int i = 0;
int j = 0;
cout << "初始状态: " << cin.good() << endl;
// 要求整型输入整型正常读取,此时就是goodbit
cin >> i;
cout << i << endl;
cout << "正常输入状态: " << cin.good() << endl;
// 要求整型输入字符型非正常读取,此时就不是goodbit
cin >> j;
cout << j << endl;
cout << "非正常输入状态: " << cin.good() << endl;
return 0;
}
我们来看一下输出结果:
我们可以来看下这几个标志位对应的行为,以及相应的函数的状态
我们可以使用库中提供的clear函数来恢复到最初的标记位
那么此时我们再此进行输入可以吗?
我们会发现此时依然是错误的,并且上面再输入abc之后并没有让我们再次输入,而是直接输出结果,为什么呢?因为clear函数只会重置我们的标记位,并不会去影响缓冲区的数据,所以此时缓冲区的数据依然存在,再次读取的时候读取的就还是abc,此时依然会输出错误,此时我们可以想办法将缓冲区的数据情况,但是我们不能使用fflush去清空,因为他是刷新输出缓冲区的,而我们这里是刷新输入缓冲区的,我们这里需要使用get()函数。
7. istream类型对象转换为逻辑条件判断值
istream& operator>> (int& val);
explicit operator bool() const;
实际上我们看到使用while(cin>>i)去流中提取对象数据时,调用的是operator>>,返回值是 istream类型的对象,那么这里可以做逻辑条件值,源自于istream的对象又调用了operator bool,operator bool调用时如果接收流失败,或者有结束标志,则返回false。
class Date
{
friend ostream& operator << (ostream& out, const Date& d);
friend istream& operator >> (istream& in, Date& d);
public:
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
operator bool()
{
// 这里是随意写的,假设输入_year为0,则结束
if (_year == 0)
return false;
else
return true;
}
private:
int _year;
int _month;
int _day;
};
istream& operator >> (istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
ostream& operator << (ostream& out, const Date& d)
{
out << d._year << " " << d._month << " " << d._day;
return out;
}
// C++ IO流,使用面向对象+运算符重载的方式
// 能更好的兼容自定义类型,流插入和流提取
int main()
{
// 自动识别类型的本质--函数重载
// 内置类型可以直接使用--因为库里面ostream类型已经实现了
int i = 1;
double j = 2.2;
cout << i << endl;
cout << j << endl;
// 自定义类型则需要我们自己重载<< 和 >>
Date d(2022, 4, 10);
cout << d;
while (d)
{
cin >> d;
cout << d;
}
return 0;
}
sync_with_stdio是C++中的一个功能,通常在使用标准输入输出流(如cin和cout)时被提及。这个功能与标准I/O库(stdio.h或stdio.hpp)的同步有关,后者是C语言的输入输出库,也被C++所兼容。在C++中,std::ios_base::sync_with_stdio(false)可以被用来禁用C++ I/O与C标准I/O之间的同步。默认情况下,这两个I/O系统是同步的,这意味着当你同时使用cin
/cout
和scanf
/printf
时,它们会互相等待,确保操作不会重叠。这对于混合使用C和C++风格的输入输出的程序来说是有帮助的,但也会带来性能上的开销,尤其是在大量数据处理时。
- 取消缓冲区同步:C++标准I/O流的缓冲区刷新不再影响C标准I/O的缓冲区,反之亦然。这意味着如果一个缓冲区满或需要刷新,它不会触发另一个缓冲区的刷新。
- 取消线程同步:在多线程环境中,这会取消C++标准I/O和C标准I/O之间的锁机制,允许它们独立操作而不必等待对方。
需要注意的是,一旦你调用了std::ios_base::sync_with_stdio(false),C++的I/O流和C的I/O函数就不再同步了。这意味着如果你在cin
和cout
之后使用了scanf
或printf
,可能会导致未预期的行为,因为缓冲区可能不会像你期望的那样刷新。
3.2 C++文件IO流
C++根据文件内容的数据格式分为二进制文件和文本文件。采用文件流对象操作文件的一般步 骤:
- 1. 定义一个文件流对象 ifstream ifile(只输入用) ofstream ofile(只输出用) fstream iofile(既输入又输出用)
- 2. 使用文件流对象的成员函数打开一个磁盘文件,使得文件流对象和磁盘文件之间建立联系
- 3. 使用提取和插入运算符对文件进行读写操作,或使用成员函数进行读写
- 4. 关闭文件
// 读取一个文件内容
#include<fstream>
int main()
{
std::ifstream ifs;
ifs.open("Test.cpp");
char ch;
while (ifs.get(ch))
{
cout << ch;
}
ifs.close();
std::ifstream ifs("Test.cpp");
char ch;
//while (ifs>>ch)//空格和换行认为是多个值,会忽略它
while (ifs.get(ch))
{
cout << ch;
}
}
我们再去尝试读一下图片,但是并没有显示出来,为什么呢?因为图片不是一个文本文件,而是一个二进制文件。
#include<fstream>
#include <iostream>
using namespace std;
int main()
{
std::ifstream ifs("seg.png", ios_base::in | ios_base::binary);
//std::ifstream ifs("Test.cpp");
char ch;
//while (ifs>>ch)
size_t n = 0;
while (ifs.get(ch))
{
++n;
cout << ch;
}
cout << endl << endl;
cout << n<< endl;
}
此时由于一些前面字符的影响,导致我们没有打印出结果n
但是我们有调式功能呀!用它来。
此时确实已经读到了,只不过我们的黑框框显示不出来。
结束绑定使用cin.tie(nullptr)。
IO效率提高的做法,不够我们日常OJ的时候不需要这样。
#include <iostream>
using namespace std;
int main()
{
// 再IO需求比较高的地方,如部分大量输入的竞赛题当中,加上以下3句代码
// 可以提高C++IO效率
std::ios_base::sync_with_stdio(false);
// 默认情况下cout和cin都是绑定的
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}
接下来我们就来看看文件流的一些使用细节。
# include <iostream>
# include <fstream>
using namespace std;
class Date
{
// 友元
friend ostream& operator<< (ostream& out, const Date& d);
friend istream& operator>> (istream& in, Date& d);
public:
Date(int year = 1, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
operator bool()
{
// 这里是随意写的,假设输入_year为0,则结束
// while(cin >> x),返回的对象是istream对象,该对象会调用operator bool()
if (_year == 0)
return false;
else
return true;
}
private:
int _year;
int _month;
int _day;
};
istream& operator>> (istream& in, Date& d) // 重载流插入
{
in >> d._year >> d._month >> d._day;
return in;
}
ostream& operator<< (ostream& out, const Date& d) // 重载流提取
{
out << d._year << " " << d._month << " " << d._day;
return out;
}
// 服务端信息
struct ServerInfo
{
char _address[32]; // 32位ip地址
//string _address; //二进制,不能读写string,写到文件是一个指针,再读回来,就一个野指针
int _port; // 端口号
Date _date; // 日期类
};
class ConfigManager
{
public:
ConfigManager(const char* filename)
:_filename(filename)
{}
// 二进制写,内存中是什么样子,就按字节一个一个写出去
// 写文件使用ofstream
void WriteBin(const ServerInfo& info)
{
ofstream ofs(_filename, ios_base::out | ios_base::binary);
ofs.write((const char*)&info, sizeof(info));
}
// 二进制读,硬盘文件中是什么样子,就按字节一个一个读出来
// 读文件使用ifstream
void ReadBin(ServerInfo& info)
{
ifstream ifs(_filename, ios_base::in | ios_base::binary);
ifs.read((char*)&info, sizeof(info));
}
// C++文件流的优势就是可以对内置类型和自定义类型,都使用
// 一样的方式,去流插入和流提取数据
// 当然这里自定义类型Date需要重载>> 和 <<
// istream& operator >> (istream& in, Date& d)
// ostream& operator << (ostream& out, const Date& d)
// 写
void WriteText(const ServerInfo& info)
{
ofstream ofs(_filename);
// 内置类型直接使用即可
ofs << info._address << endl;
ofs << info._port << endl;
ofs << info._date << endl; // 对于Data自定义类型已经重载流插入
}
// 读
void ReadText(ServerInfo& info)
{
ifstream ifs(_filename);
// 内置类型直接使用即可
ifs >> info._address;
ifs >> info._port;
ifs >> info._date; // 对于Data自定义类型已经重载流提取
}
private:
string _filename; // 配置文件
};
我们再来分别进行二进制读写
int main()
{
// 二进制写
ServerInfo wbinfo = { "192.168.1.10", 80, { 2024, 7, 15 } };
ConfigManager cf_bin("test.bin");
cf_bin.WriteBin(wbinfo); // 二进制写文件
// 二进制读
// ConfigManager cf_bin("test.bin");
ServerInfo rbinfo;
cf_bin.ReadBin(rbinfo); // 二进制读文件
cout << rbinfo._address << " " << rbinfo._port << " " << rbinfo._date << endl;
return 0;
}
我们来看一下运行结果:
我们再来看看文本读写的代码
int main()
{
// 文本写 只能写字符串
ServerInfo winfo = { "192.0.0.1", 80, { 2024, 7, 15 } };
ConfigManager cf_text("test.text");
cf_text.WriteText(winfo);
// 文本读
// ConfigManager cf_text("test.text");
ServerInfo rtinfo;
cf_text.ReadText(rtinfo);
cout << rtinfo._address << " " << rtinfo._port << " " << rtinfo._date << endl;
return 0;
}
我们来看一下运行结果:
当我们在程序中处理字符串时,我们通常认为它们是一串字符,以空字符\0作为结尾。在C语言或类似的语言中,字符串本质上是一个字符数组的别名。然而,在内存中,字符串实际上只是一个指向该字符数组起始位置的指针。
当你将一个字符串“写入”到二进制文件中,如果只是简单地保存字符串变量本身(即指针),而不是实际的字符数据,那么你实际上是在文件中存储了一个内存地址。这个地址在你的程序运行环境中是有意义的,它指向当前进程内存空间中字符串的实际位置。
问题在于,当你关闭程序并再次打开二进制文件读取这个地址时,原始的内存地址已经失去了意义。操作系统会在每次程序运行时分配不同的内存区域给进程,这意味着之前存储的地址现在很可能不再指向任何有效的数据,从而导致一个野指针(dangling pointer)。野指针是指向不可访问或不确定的内存位置的指针,访问这样的指针会导致未定义行为,比如程序崩溃。
为了避免这个问题,正确的做法是将字符串的内容(即字符数组中的所有字符,包括结束符\0)写入文件,而不是字符串的地址。这样,无论何时读取文件,你都会得到字符串的实际内容,而不会遇到无效的指针。
现在有一个细节问题来了,为什么这里传入的是ofstream的对象,却能够传参给ostream类型的对象呢?在C++中,ofstream类实际上是ostream类的一个子类。ofstream继承自ostream,并且添加了一些额外的功能,特别是那些与文件输出相关的功能。这意味着ofstream对象拥有ostream的所有属性和方法,那这里是继承还是多态呢?首先我们要了解多态的条件:
- 必须通过基类的指针或者引用调用虚函数
- 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写
此时我们虽然满足第一个条件,但是第二个条件我们就不满足,我们调用的函数并不是虚函数,所以这里就是一个继承,我们这里就是典型的是一个继承,直接去调用父类的方法。
3.3. stringstream的简单介绍
在C语言中,如果想要将一个整形变量的数据转化为字符串格式,如何去做?
- 1. 使用itoa()函数
- 2. 使用sprintf()函数
但是两个函数在转化时,都得需要先给出保存结果的空间,那空间要给多大呢,就不太好界定, 而且转化格式不匹配时,可能还会得到错误的结果甚至程序崩溃。
在C++中,可以使用stringstream类对象来避开此问题。 在程序中如果想要使用stringstream,必须要包含头文件。在该头文件下,标准库三个类: istringstream、ostringstream 和 stringstream,分别用来进行流的输入、输出和输入输出操 作,本文主要介绍stringstream。 stringstream主要可以用来:
1. 将数值类型数据格式化为字符串
#include<sstream>
int main()
{
int a = 12345678;
string sa;
// 将一个整形变量转化为字符串,存储到string类对象中
stringstream s;
s << a;
s >> sa;
// clear()
// 注意多次转换时,必须使用clear将上次转换状态清空掉
// stringstreams在转换结尾时(即最后一个转换后),会将其内部状态设置为badbit
// 因此下一次转换是必须调用clear()将状态重置为goodbit才可以转换
// 但是clear()不会将stringstreams底层字符串清空掉
// s.str("");
// 将stringstream底层管理string对象设置成"",
// 否则多次转换时,会将结果全部累积在底层string对象中
cout << sa << endl;
s.str("");
s.clear();
// 清空s, 不清空会转化失败
double d = 12.34;
s << d; // 将d写入到s
s >> sa; // 将从s中读取的数据给sa,会覆盖掉之前sa的内容
string sValue;
sValue = s.str();
// str()方法:返回stringsteam中管理的string类型
cout << sValue << endl;
cout << sa << endl;
return 0;
}
2. 字符串拼接
# include <sstream>
int main()
{
stringstream sstream;
// 将多个字符串写入 sstream 中
sstream << "first" << " " << "string,";
sstream << " second string";
cout << "strResult is: " << sstream.str() << endl;
// 清空 sstream
sstream.str("");
sstream << "third string";
cout << "After clear, strResult is: " << sstream.str() << endl;
return 0;
}
3. 序列化和反序列化结构数据
struct ChatInfo
{
string _name; // 名字
int _id; // id
Date _date; // 时间
string _msg; // 聊天信息
};
# include <sstream>
// 结构体转化为字符串
int main()
{
ostringstream oss;
ChatInfo winfo = { "张三",123456, {2024, 7, 19}, "咱们一起打游戏吧!" };
// 此时不是写到我们的控制台当中,而是转化为字符串写入到ostringstream里面
oss << winfo._name << " " << winfo._id << " " << winfo._date << " " << winfo._msg;
// 怎么拿到呢?使用str()函数
string str = oss.str();
cout << str << endl;
return 0;
}
我们来看一下运行结果:
其实我们看到这里就会发现上面的ostringstream实际上就是我们网络里面的序列化,将用户端输入的内容转为字符串,这样我们才能将数据发送出去,那服务端收到数据就需要反序列化,将字符串再转化为客户端输入的内容进行处理,那么接下来我们就需要进行反序列化
// 结构体转化为字符串
int main()
{
ostringstream oss;
ChatInfo winfo = { "张三",123456, {2024, 7, 19}, "咱们一起打游戏吧!" };
// 此时不是写到我们的控制台当中,而是转化为字符串写入到ostringstream里面
// 序列化
oss << winfo._name << " " << winfo._id << " " << winfo._date << " " << winfo._msg;
// 怎么拿到呢?使用str()函数
string str = oss.str();
cout << str << endl;
// 通过网络套接字给服务端,服务端读取之后需要解析 - 反序列化
istringstream iss(str);
ChatInfo rinfo;
// 此时不是从键盘读,而是从istringstream里面读
iss >> rinfo._name >> rinfo._id >> rinfo._date >> rinfo._msg;
// 读完之后我们就可以进行反序列化 + 解析
cout << "-------------------------------------------------------" << endl;
cout << "姓名:" << rinfo._name << "(" << rinfo._id << ")" ;
cout << rinfo._date << endl;
cout << rinfo._name << ":>" << rinfo._msg << endl;
cout << "-------------------------------------------------------" << endl;
return 0;
}
我们来看一下运行结果:
但是此时我们要注意一个点,如果我们此时从istringstream中读取的顺序和结构体中的变量定义的顺序不一样,此时结果是错误的。
此时我们读取的是一个字符串,但是我们用整形去接受,此时就会出现错误,此时goodbit标志位就会被置为0,这里我们可以来验证一下这几个比特位。
此时我们就需要使用上面提到过的clear函数去重置一下标志,此时按照正常的顺序去读才不会出现问题。
注意:
- 1. stringstream实际是在其底层维护了一个string类型的对象用来保存结果。
- 2. 多次数据类型转化时,一定要用clear()来清空,才能正确转化,但clear()不会将 stringstream底层的string对象清空。
- 3. 可以使用s. str("")方法将底层string对象设置为""空字符串。
- 4. 可以使用s.str()将让stringstream返回其底层的string对象。
- 5. stringstream使用string类对象代替字符数组,可以避免缓冲区溢出的危险,而且其会对参 数类型进行推演,不需要格式化控制,也不会出现格式化失败的风险,因此使用更方便,更安全。