在C语言中我们使用最频繁的输入输出方式是 scanf () 与 printf():
实际上C语言借助了相应的缓冲区来进行输入与输出。如下图所示:
对输入输出缓冲区的理解:
注:C语言除了有输入输出接口 scanf 和 printf,还有文件操作读写接口 fread/fwrite、fscanf/fprintf,以及字符串序列化反序列化接口 sprintf/snprintf/sscanf。
“流” 即是流动的意思,是物质从一处向另一处流动的过程,是对一种有序连续且具有方向性的数据( 其单位可以是bit/byte/packet )的抽象描述。流的特点是有序连续且具有方向性。
C++流是指信息从外部输入设备(如键盘)向计算机内部(如内存)输入和从内存向外部输出设备(显示器)输出的过程。这种输入输出的过程被形象的比喻为 “流”。
为了实现这种流动,C++定义了I/O标准类库,这些每个类都称为流/流类,用以完成某方面的功能。
C++系统实现了一个庞大的 I/O 标准类库,其中ios为基类,其他类都是直接或间接派生自ios类:
C++标准库提供了4个全局流对象cin、cout、cerr、clog:
从 I/O 标准类库的继承体系图中可以看出,cout、cerr、clog 是 ostream 类的三个不同的对象,因此这三个对象基本没有区别,只是应用场景不同而已。
注:在使用这些全局对象流时必须要包含文件并引入std标准命名空间。
在使用 cin/cout 标准输入输出时有如下注意事项:
流插入和流提取运算符的重载
cin 和 cout 之所以可以直接输入和输出内置类型数据,是因为标准库已经将所有内置类型的输入和输出全部重载了。
所以对于自定义类型来说,如果我们想让其支持 cin/cout 标准输入输出,就需要手动重载 >> 和 << 运算符。需要注意的是,自定义类型在重载流插入和流提取运算符时,需要先将 operator<< 和 operator>> 声明为类的友元函数,然后再在类外对函数进行定义,至于原因我们在 类和对象下篇 中有详细介绍,不清楚的同学可以看一看。
下面我们给出日期类输入输出重载的例子:
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)
{}
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++中的类的上下文转换指的是在特定的上下文环境中,将对象或表达式隐式地转换为其他类型。这种转换是由编译器自动进行的,不需要从代码中显式地进行调用。常见的上下文转换包括:
数值类型转换和派生类基类转换我们之前都已经学习过了,今天我们来学习用户定义类型转换。下面我通过一个例子来引入。
我们平时在做 OJ 题的时候,特别是 ACM 模式的 OJ 题,对于IO类型的算法,一般都需要循环输入,如下:
// 单个元素循环输入--元素为内置类型
while (cin >> a)
{
// ...
}
// 多个元素循环输入
while (c >> a >> b >> c)
{
// ...
}
// 整行接收--元素为string类型
while (cin >> str)
{
// ...
}
可以看到,我们的案例中包含了 string 类型;但是我们又发现,string 类中重载的流提取运算符 operator>> 的返回值是 istream 类型的对象。
那么问题来了,我们平时只有三种类型的数据能够用来作为逻辑判断:
而 istream 作为自定义类型的对象如何能够作为逻辑判断的条件呢?答案是 istream 类内部重载了 bool:
综上,由于 istream 类中重载了流提取运算符,所以当我们使用 while (cin >> str)
去流中提取对象数据时,调用的是 operator>>
,该函数返回一个 istream类型的对象;同时,因为 istream 类中还重载了 bool,所以 istream 对象会去调用 operator bool
函数;operator bool
调用时如果接收流失败,或者有结束标志,返回 false,否则返回 true;所以这里自定义类型 istream 的对象可以用作逻辑条件值。
注:在需要 bool 类型的地方,比如条件判断处,编译器会自动调用 operator bool
函数,将自定义类型转化为 bool 类型。同时,operator bool
函数被 explicit
关键字修饰,这是防止隐式地将一个类对象转换成 bool 类型,从而在条件判断上造成误解。
我们也可以在我们自己的自定义类中重载 operator>>
和operator bool
,从而让其支持进行作为逻辑判断值:
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;
}
int main()
{
//自动识别类型的本质--函数重载
//内置类型可以直接使用--因为库里面ostream类型已经实现了
//string类型也可以直接使用,因为其内部也重载了,但其他自定义类型不行
int i = 1;
double j = 2.2;
string s("abcdef");
cout << i << endl;
cout << j << endl;
cout << s << endl;
//自定义类型则需要我们自己重载<< 和 >>
//如果要让自定义类型对象能够作为逻辑判断值,还需要重载bool、int等运算符
Date d(2023, 5, 30);
cout << d << endl;
while (d)
{
cin >> d;
cout << d << endl;
}
return 0;
}
注意:并不是一定要重载 bool 类对象才能作为逻辑条件值,重载整形、指针类型都可以,因为它们都能够进行逻辑判断。同时,operator bool
其本质是通过重载将自定义类型转化为内置类型,它的使用可以不仅仅局限于用作逻辑条件值,也可以用作其他地方。
C++ 中一共有三个用于文件操作的类 ifstream/ofstream/fstream,如下:
这三个类的关系如图:
下面我们以 fstream 类为例来解释 C++ 中面向对象的文件操作,其他两个类的使用和 fstream 类的使用基本一样。
构造函数
fstream 支持无参构造和带参构造,不支持拷贝构造,支持移动构造:
特别注意:fstream 默认情况下以只读形式打开文件,以文本格式向文件中读取和写入数据。同时,文件对象在析构时会自动调用 close 成员函数关闭文件;当然,我们也可以手动调用 close 来关闭文件。
文件操作相关成员函数
我们可以使用流提取和流插入运算符对文件进行读写操作,或使用成员函数进行读写。
需要注意的是,虽然 ifstream/ofstream/fstream 类中提供了非常丰富的成员函数来让我们对文件进行操作:
但是这些接口在实际开发中其实用的最多的还是 operator<<
**和**operator>>
,其他接口都用的很少,包括 read 和 write 接口。这是因为operator<<
和operator>>
使用起来非常方便,通过这两个接口向文件中读取和写入数据就和我们向标准输入输出中写入读出数据一样 – cin 从文件/标准输入读取数据,cout 向文件/标准输出写入数据 (其实本质上标准输入输出也是文件,或者是流)。
下面是 C++ 面向对象文件操作的一个示例:
struct ServerInfo
{
char _address[32];
int _port;
Date _date;
};
struct ConfigManager
{
public:
ConfigManager(const char* filename)
:_filename(filename)
{}
void WriteBin(const ServerInfo& info)
{
ofstream ofs(_filename, ios_base::out | ios_base::binary);
ofs.write((const char*)&info, sizeof(info));
}
void ReadBin(ServerInfo& info)
{
ifstream ifs(_filename, ios_base::in | ios_base::binary);
ifs.read((char*)&info, sizeof(info));
}
//C++文件流的优势就是可以对内置类型和自定义类型,都使用一样的方式,去流插入和流提取数据
//但是需要自定义类型Date重载了>> 和 <<
void WriteText(const ServerInfo& info)
{
//默认以文本格式向文件中读取和写入数据
ofstream ofs(_filename);
//这里可以调用成员函数write,但是<<运算符更方便
ofs << info._address << " " << info._port << " " << info._date;
}
void ReadText(ServerInfo& info)
{
ifstream ifs(_filename);
ifs >> info._address >> info._port >> info._date;
}
private:
string _filename; // 配置文件
};
int main()
{
ServerInfo winfo = { "192.0.0.1", 80, { 2023, 5, 30 } };
// 二进制读写
ConfigManager cf_bin("test.bin");
cf_bin.WriteBin(winfo);
ServerInfo rbinfo;
cf_bin.ReadBin(rbinfo);
cout << rbinfo._address << " " << rbinfo._port << " " << rbinfo._date << endl;
// 文本读写
ConfigManager cf_text("test.text");
cf_text.WriteText(winfo);
ServerInfo rtinfo;
cf_text.ReadText(rtinfo);
cout << rtinfo._address << " " << rtinfo._port << " " << rtinfo._date << endl;
return 0;
}
注意:如果文件是以二进制格式打开的,则不能直接向文件中写入 string 对象;因为 string 是自定义类型,其中除了有 char* _str
字符数组之外,还有很多其他成员变量和成员函数,若直接将其写入到文件中,那么写入的数据就是该对象所占用的内存空间,即对象中成员变量和成员函数的地址,而不是字符串本身的内容,即 _str 变量指向的堆空间中的字符数组。这样,在读取文件时,就无法正确地获取原始字符串数据 (下次进行读取时该对象可能已经被销毁,再通过旧对象中成员变量的地址去访问堆上的字符数组会造成野指针访问)。
但以文本格式打开的文件可以直接向其中写入 string 对象;因为在文本文件中,数据是按照字符编码的形式存储的,即将单个字符转换成相应的数字形式后再存储到文件中,即将堆空间中字符数组对应的 ASCII 值写入到文件。因此,字符串数据可以直接以文本形式写入到文件中,并在读取时直接通过 >>
运算符等操作进行读取。
在C语言中,如果想要将内置类型/结构体类型的数据转化为字符串格式,通常是使用 sprintf/snprintf 函数,但是这两个函数在使用时需要先给出保存结果的空间,而空间要给多大,是不好界定的。并且当转化格式不匹配时,还可能会得到错误的结果甚至程序直接崩溃。
C++ 提供了 stringstream 类来解决这个问题。stringstream 包含在 <sstream> 头文件中,该头文件下主要有三个类:istringstream、ostringstream 和 stringstream,分别用来进行流的输入、输出和输入输出操作,本文主要介绍 stringstream。
stringstream 主要有以下用途:
将数值类型数据格式化为字符串。
#include<sstream>
int main()
{
int a = 12345678;
string sa;
// 将一个整形变量转化为字符串,存储到string类对象中
stringstream s;
s << a;
s >> sa;
cout << sa << endl;
// clear()
// 注意多次转换时,必须使用clear将上次转换状态清空掉
// stringstreams在转换结尾时(即最后一个转换后),会将其内部状态设置为badbit
// 因此下一次转换是必须调用clear()将状态重置为goodbit才可以转换
// 但是clear()不会将stringstreams底层字符串清空掉
// s.str("");
// 将stringstream底层管理string对象设置成"",
// 否则多次转换时,会将结果全部累积在底层string对象中
s.str("");
s.clear(); // 清空s, 不清空会转化失败
double d = 12.34;
s << d;
s >> sa;
string sValue;
sValue = s.str(); // str()方法:返回stringsteam中管理的string类型
cout << sValue << endl;
return 0;
}
字符串拼接。
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;
}
序列化和反序列化结构数据。
struct ChatInfo
{
string _name; // 名字
int _id; // id
Date _date; // 时间
string _msg; // 聊天信息
};
int main()
{
// 结构信息序列化为字符串
ChatInfo winfo = { "张三", 135246, { 2022, 4, 10 }, "晚上一起看电影吧" };
//将结构数据序列化到stringstream对象中
ostringstream oss;
oss << winfo._name << " " << winfo._id << " " << winfo._date << " " << winfo._msg;
//将stringstream中的字符串反序列化到string对象中或直接输出
string str = oss.str();
cout << str << endl << endl;
// 我们通过网络这个字符串发送给对象,实际开发中,信息相对更复杂,
// 一般会选用Json、xml等方式进行更好的支持
// 字符串解析成结构信息
ChatInfo rInfo;
istringstream iss(str);
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;
}
需要注意的是:
stringstream 有如下注意事项: