文章目录
一. 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;
}
编译运行
219
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
