一. C语言和C++的输入输出
1. 优缺点比较
C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。 scanf(): 从标准输入设备(键盘)读取数据，并将值存放在变量中。printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。
- 优点：输入输出时，配合文字描述和数字的格式控制更加方便。
- 缺点：不同类型数据的输入输出需要对应的格式匹配。
C++中通常配合使用输入流对象cin完成数据的输入，输出流对象cout完成数据的输出。
- 优点：输入输出时自动识别类型。
- 缺点：输入输出时，配合文字描述和数字的格式控制较为麻烦。
struct Person { int _age; string _name; }; int main() { Person p; // C++输入输出 cin>>p._age>>p._name; cout<<"年龄:"<<p._age<<" "<<"姓名:"<<p._name<<endl; // C语言输入输出 scanf("%d%s",&p._age, (char*)p._name.c_str());// 因为c_str返回的是const char*，我们的输入涉及到修改，所以强转为char* printf("年龄%d 姓名:%s\n", p._age, p._name.c_str()); }
编译运行
2. scanf对string类对象操作时带来的几个问题
2.1 string类框架介绍
C语言的输入输出也适用于string类对象，但string类对象封装了char*，想要拿到并操作它，需要c_str。
// string类对象基本框架 class string { public: // 注意返回的是const char* const char* c_str() const { return _str; } //... private: char* _str;// 存储字符的字符串 size_t _size;// 记录当前字符数量 size_t _capacity;// 记录当前容量 };
2.2 问题一：scanf输入时产生的错误
下面我们用scanf对string类对象进行输入：
int main() { string s; // cin和cout输入输出 cin>>s; cout<<s<<endl; cout<<"string对象的容量:"<<s.capacity()<<endl; // 仅scanf输入 scanf("%s", (char*)s.c_str()); return 0; }
编译运行
造成这个问题的原因是一开始时我们用cin操作string类对象输入三个字符，其中如果容量(即成员变量里的_capacity)不够了，会自动完成增容。之后我们用scanf输入更长的大于原本的容量的字符串，它无视容量，只管往那块连续空间输入，就造成了内存的非法访问。
2.3 问题二：scanf输入正确，用cout输出时产生的错误
接下来保证空间足够的情况下用scanf对string类对象进行输入，cout对其输出，看看还会出什么问题：
int main() { string s; s.reserve(100);// 预留100字节空间 // 1、cin和cout输入输出 cin>>s; cout<<s<<endl; cout<<"string类对象的size为:"<<s.size()<<endl; // 2、scanf和printf出入输出 scanf("%s", (char*)s.c_str()); cout<<s<<endl; return 0; }
编译运行
我们发现，这次scanf输入是没问题了，但是用cout输出的结果并不是我们想要的。原因是重载的输出流操作符 “<<” ，实现原理是按照string类的成员变量_size的大小来一个字符一个字符输出的，即_size是多少就输出几个字符。
// string类对象基本框架 class string { public: ostream& operator<<(ostream& out, const string& s) { int len = s._size(); // 把字符串的字符一个一个的输出，共输出size个 for (size_t i = 0; i < s.size(); i++) { out << s[i]; } // 最后还要返回out，为了支持连续的<<操作 return out; } //... private: char* _str;// 存储字符的字符串 size_t _size;// 记录当前字符数量 size_t _capacity;// 记录当前容量 };
这时如果用printf输出就没问题，因为printf的输出是遇到 ‘\0’ 就停止，不看string类对象的_size是多少。
3. 使用场景总结
在C编程中建议只用scanf和printf，而在C++中输入用cin，输出如果有复杂的文字描述或数字的格式控制需求的话，可以用printf，其他情况都用cot。
二. 输入输出缓冲区
1. 基本概念
我们在终端上输入的数据都会放到内存中的输入缓冲区里，当有对象需要提取数据时直接从输入缓冲区中提取。对象输出数据之前也要先把数据放到输出缓冲区里，待满足特定的条件后才从其中刷新出来。
2. 输入缓冲区的提取规则
规定当对象从输入缓冲区中提取数据时，遇到空格(’ ‘)、回车(’\n’)或换行(’\r’)时算读取结束，并且不会提取到上面的三个字符。
int main() { string s1; string s2; cin>>s1; cout<<"s1："<<s1<<endl; cin>>s2; cout<<"s2："<<s2<<endl; return 0; }
编译运行
我们只输入"hello world\r\n"，按照上面的规则：以空格和回车、换行为提取结束标志，s1和s2依次从输入缓冲区中提取到对应字符串。
使用getline提取一行字符串
但我们有需求提取带空格的一连串字符，并且以换行作为提取结束标志，这时可以考虑使用getline。它是string类定义的一个成员函数：
其模拟实现大致如下：
istream& getline(istream& in, string& s) { while (1) { char c = in.get(); if (c == '\n')// 从缓冲区接收数据，遇到换行才停止 { break; } else { s += c; } } return in; }
使用示范
int main() { string s1; string s2; getline(cin, s1); cout<<"s1："<<s1<<endl; getline(cin, s2); cout<<"s2："<<s2<<endl; return 0; }
编译运行
3. 输出缓冲区的刷新规则
当我们用printf或cout输出内容时，不会立即输出到输出设备，而是先存储在内存中的输出缓冲区中，满足一定条件才会刷新到输出设备，这些条件包括：
- 输出缓冲区被填满
- 写入的字符中有’\n’或’\r’
- 调用fflush手动刷新
- 程序结束
下面举个例子说明来缓冲区的刷新规则：在通常的认知里，下面这段程序按照顺序执行应该先输出一连串’#'字符，然后睡眠三秒，随后进程终止。
int main() { cout<<"###################################"; sleep(3); return 0; }
实际运行结果：先睡眠三秒，然后才输出一连串’#’字符
原因是在执行cout输出的时候，我们要输出的数据中没有换行或回车，所以数据放到输出缓冲区里没有刷新到输出设备，然后往下运行sleep三秒，最后进程结束才把输出缓冲区的内容全部刷新出来，造成了sleep先执行的假象。
三. OJ中的连续输入
1. 连续输入的场景
OJ中的题目分为两种类型：IO型和接口型。其中IO型由于后台要连续输入测试用例，可能要求我们设计一个连续输入的模式，比如下图这个：
2. C语言中的连续输入
int main() { char buff[100]; //也可以这样写：while(~scanf("%s", buff)) while((scanf("%s", buff)) != EOF) { printf("%s\n", buff); } return 0; }
原理分析
其中EOF为-1，我们按ctrl + c可以结束连续输入，这时系统会向scanf发送终止信号，让它返回-1。
因为-1的补码是全1，按位取反后变为0，所以也可以通过按位取反来作为判断结束的条件。
3. C++中的连续输入
int main() { string s; while(cin>>s) { cout<<s<<endl; } return 0; }
这里是string类重载了>>操作符，它返回输入流对象，我们这里是cin，同样按 ctrl + c结束输入。
运算符返回的是流对象的引用，cin是一个流对象，而>>运算符返回左边的流对象，也就是说cin>>val返回cin，于是while(cin>>val)就变成了while(cin)，问题就变成了一个流对象在判断语句中的合法性。
打开iostream.h文件，可以看到从ios继承来的 operator void*() const和bool operator!() const 这两个函数。在流对象进行逻辑判断时，会自动调用这两个成员函数，使得流对象可作为判断语句的内容。
原理分析
在没有重载 operator void* 和 operator! 的情况下，我们声明一个普通的类，看看这个类定义出来的对象能不能用作判断条件：
class A {}; int main() { A a; if(a)// 用a作为判断条件 { cout<<"Yes"<<endl; } return 0; }
编译错误，说是不能把类型A转化成bool
接下来轮到 operator void* 登场了，它是强制类型转换运算符的重载，为了区别于仿函数的重载，对其格式做了特殊要求：函数名为我们期望被强转成的那个类型。
我们要强转的类型为void* ，它是“无类型指针”，可以指向任何类型的数据，所以不需要返回值。当流对象作为判断条件时，会自动调用这个函数完成 if(cin)到if((void*)cin)的转化。
class A { public: operator void*() { cout<<"operator void*()"<<endl; return (void*)0; } }; int main() { A a; if(!a)// -> if(!(void)a) { cout<<"Yes"<<endl; } return 0; }
编译运行
在逻辑判断时，经常还会用到 ! 来修饰判断条件，我们也可以直接重载operator !()，当对象要用来进行逻辑判断且前面有 ! 修饰时，自动调用operator !()完成逻辑判断。
class A { public: operator void*() { cout<<"operator void*()"<<endl; return (void*)0; } bool operator!() { cout<<"operator!()"<<endl; return true; } }; int main() { A a; if(!a)// -> if(a.opeartor !()) { cout<<"Yes"<<endl; } return 0; }
编译运行，我们发现这次仅仅调用了operator !()，而没有调用operator void*()
当然，它们的内部实行没那么简单，可能满足不同的条件会返回不同的值，比如< iostream >里对上面两个操作符的重载中可能就有接收到退出信号（即我们按 crl + c），就返回flase这种条件判断。
下面演示一个例子
class A { public: operator void*() { if(_count<3) { cout<<"Yes"<<endl; return (void*)this; } else { cout<<"No"<<endl; return (void*)0; } } int _count=0; }; int main() { A a; while(a) { ++a._count; } return 0; }
编译运行
