OJ输入输出总结
0.牛客练习场
1.标准输入输出
-
cin是istream类的对象
-
cout不是C++预定义的关键字，是ostream流类的对象
cin、cout为流对象，类中还有许多函数可以调用。如cin.get()等 。
按照格式输出：
#include <iostream>
#include <iomanip>//不要忘记包含此头文件
using namespace std;
int main()
{
int a;
cout<<"input a:";
cin>>a;
cout<<"dec:"<<dec<<a<<endl; //以十进制形式输出整数
cout<<"hex:"<<hex<<a<<endl; //以十六进制形式输出整数a
cout<<"oct:"<<setbase(8)<<a<<endl; //以八进制形式输出整数a
char *pt="China"; //pt指向字符串"China"
cout<<setw(10)<<pt<<endl; //指定域宽为,输出字符串
cout<<setfill('*')<<setw(10)<<pt<<endl; //指定域宽,输出字符串,空白处以'*'填充
double pi=22.0/7.0; //计算pi值
//按指数形式输出,8位小数
cout<<setiosflags(ios::scientific)<<setprecision(8);
cout<<"pi="<<pi<<endl; //输出pi值
cout<<"pi="<<setprecision(4)<<pi<<endl; //改为位小数
cout<<"pi="<<setiosflags(ios::fixed)<<pi<<endl; //改为小数形式输出
return 0;
}
1.1.cin>>
cin>>当读取字符串的时候需要注意，cin不能读取空白字符，比如空格，如果遇到空格则会直接终止字符串。
当遇到无效字符或遇到文件结束符（不是换行符，是文件中的数据已读完）时，输入流cin就处于出错状态，即无法正常提取数据。此时对cin流的所有提取操作将终止。在 IBM PC及其兼容机中，以Ctrl + Z表示文件结束符。在UNIX和Macintosh系统中，以 Ctrl + D表示文件结束符。当输入流cin处于出错状态时，如果测试cin的值，可以发现它的值为false(假)，即cin为0值。如果输入流在正常状态，cin的值为true(真)，即cin为 一个非0值。可以通过测试cin的值，判断流对象是否处于正常状态和提取操作是否成功。
可用于判断：while(cin>>a)
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s; // 读到空白就结束当前的字符串
cout << s;
return 0;
}
1.2.cin.get()不带参数
#include <iostream>
using namespace std;
int main( )
{
int c;
cout<<"enter a sentence:"<<endl;
while((c=cin.get())!=EOF)//不带参数的cin.get(),返回值为读入的字符
cout.put(c);
return 0;
}
1.3.cin.get(ch)带一个参数
从输入流中读取一个字符，赋给字符变量ch。如果读取成功则函数返回true(真)，如失败(遇文件结束符) 则函数返回false(假)。
#include <iostream>
using namespace std;
int main( )
{
char c;
cout<<"enter a sentence:"<<endl;
while(cin.get(c)) //读取一个字符赋给字符变量c,如果读取成功,cin.get(c)为真
{
cout.put(c);
}
cout<<"end"<<endl;
return 0;
}
1.4.cin.get(字符数组， 字符个数n, 终止字符)带三个参数
#include <iostream>
using namespace std;
int main( )
{
char ch[20];
cout<<"enter a sentence:"<<endl;
cin.get(ch,10,'\\n');//指定换行符为终止字符
cout<<ch<<endl;
return 0;
}
get函数中第3个参数可以省写，此时默认为’\n’。下面两行等价：
cin.get(ch,10,'\\n');
cin.get(ch,10);
终止字符也可以用其他字符。如
cin.get(ch,10,'x');
在遇到字符’x’时停止读取操作。
1.5.cin.getline()
getline函数的作用是从输入流中读取一行字符,其用法与带3个参数的get函数类似。即 cin.getline(字符数组(或字符指针), 字符个数n, 终止标志字符)
#include <iostream>
using namespace std;
int main( )
{
char ch[20];
cout<<"enter a sentence:"<<endl;
cin>>ch;
cout<<"The string read with cin is:"<<ch<<endl;
cin.getline(ch,20,'/'); //读个字符或遇'/'结束
cout<<"The second part is:"<<ch<<endl;
cin.getline(ch,20); //读个字符或遇'/n'结束
cout<<"The third part is:"<<ch<<endl;
return 0;
}
1.6.getline(cin,str)
getline(cin,str)，读取整行数据到str中.
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
getline(cin, s);
cout << s;
system("pause");
return 0;
}
2.文件输入输出
2.1.文件流类与文件流对象
类比标准输入输出流类istream、ostream和iostream类，有3个用于文件操作的文件类：
- ifstream类，它是从istream类派生的，用来支持从磁盘文件的输入。
- ofstream类，它是从ostream类派生的，用来支持向磁盘文件的输出。
- fstream类，它是从iostream类派生的，用来支持对磁盘文件的输入输出。
对磁盘文件的操作是通过文件流对象（而不是cin和cout）实现的。文件流对象是用文件流类定义的，而不是用istream和ostream类来定义的。可以用下面的方法建立一个输出文件流对象： ofstream outfile;
如同在头文件iostream中定义了流对象cout —样，现在在程序中定义了outfile为 ofstream类（输出文件流类）的对象。
2.2.打开(输出)文件
1) 调用文件流的成员函数open
ofstream outfile; //定义ofstream类(输出文件流类)对象outfile
outfile.open("f1.dat",ios::out); //使文件流与f1.dat文件建立关联
调用成员函数open的一般形式为： 文件流对象.open(磁盘文件名, 输入输出方式);
2) 在定义文件流对象时指定参数
ostream outfile("f1.dat",ios::out);一般多用此形式，比较方便。作用与open函数相同。
ios::in 以输入方式打开文件
ios::out 以输出方式打开文件（这是默认方式），如果已有此名字的文件，则将其原有内容全部清除
ios::app 以输出方式打开文件，写入的数据添加在文件末尾
ios::ate 打开一个已有的文件，文件指针指向文件末尾
ios: :trunc 打开一个文件，如果文件已存在，则删除其中全部数据，如文件不存在，则建立新文件。如已指定了 ios::out 方式，而未指定ios: :app，ios::ate，ios: :in，则同时默认此方式
ios:: binary 以二进制方式打开一个文件，如不指定此方式则默认为ASCII方式
ios::nocreate 打开一个已有的文件，如文件不存在，则打开失败。nocrcate的意思是不建立新文件
ios:: noreplace 如果文件不存在则建立新文件，如果文件已存在则操作失败，replace 的意思是不更新原有文件
ios::in l ios::out 以输入和输出方式打开文件，文件可读可写
ios:: out | ios::binary 以二进制方式打开一个输出文件
ios::in l ios::binar 以二进制方式打开一个输入文件
可以用“位或”运算符“|”对输入输出方式进行组合.
ios::in | ios:: noreplace //打开一个输入文件，若文件不存在则返回打开失败的信息
ios::app | ios::nocreate //打开一个输出文件，在文件尾接着写数据，若文件不存在，则返回打开失败的信息
ios::out l ios::noreplace //打开一个新文件作为输出文件，如果文件已存在则返回打开失败的信息
ios::in l ios::out I ios::binary //打开一个二进制文件，可读可写
如果打开操作失败，open函数的返回值为0(假)，如果是用调用构造函数的方式打开文件的，则流对象的值为0。可以据此测试打开是否成功。如
if(outfile.open("f1.bat", ios::app) ==0)
cout <<"open error";
或
if( !outfile.open("f1.bat", ios::app) )
cout <<"open error";
例子：输出保存。从键盘输入个整数给数组，将此数组送到磁盘文件中存放。
#include <fstream>
using namespace std;
int main( )
{
int a[10];
ofstream outfile("f1.dat",ios::out);//定义文件流对象,打开磁盘文件"f1.dat"
if(!outfile) //如果打开失败,outfile返回值
{
cerr<<"open error!"<<endl;
exit(1);
}
cout<<"enter 10 integer numbers:"<<endl;
for(int i=0;i<10;i++)
{
cin>>a[i];
outfile<<a[i]<<" ";
} //向磁盘文件"f1.dat"输出数据
outfile.close(); //关闭磁盘文件"f1.dat"
return 0;
}
例子：输入数据。从上例建立的数据文件f1.dat中读入个整数放在数组中，找出并输出个数中的最大者和它在数组中的序号。
#include <fstream>
using namespace std;
int main( )
{
int a[10],max,i,order;
//定义输入文件流对象,以输入方式打开磁盘文件f1.dat
ifstream infile("f1.dat",ios::in|ios::nocreate);
if(!infile)
{
cerr<<"open error!"<<endl;
exit(1);
}
for(i=0;i<10;i++)
{
infile>>a[i]; //从磁盘文件读入10个整数,顺序存放在a数组中
cout<<a[i]<<" "; //在显示器上顺序显示10个数
}
cout<<endl;
max=a[0];
order=0;
for(i=1;i<10;i++)
if(a[i]>max)
{
max=a[i]; //将当前最大值放在max中
order=i; //将当前最大值的元素序号放在order中
}
cout<<"max="<<max<<endl<<"order="<<order<<endl;
infile.close();
return 0;
}
例子。将磁盘文件内容读入内存，然后输出到显示器。
#include <fstream>
using namespace std;
void display_file(char *filename)
{
ifstream infile(filename,ios::in|ios::nocreate);
if(!infile)
{
cerr<<"open error!"<<endl;
exit(1);
}
char ch;
while(infile.get(ch))
cout.put(ch);
cout<<endl;
infile.close();
}
// 然后在调用时给出文件名即可
int main( )
{
display_file("f3.dat");//将f3.dat的入口地址传给形参filename
return 0;
}
2.3.关闭文件
在对已打开的磁盘文件的读写操作完成后，应关闭该文件。关闭文件用成员函数close。如
outfile.close( ); //将输出文件流所关联的磁盘文件关闭
所谓关闭，实际上是解除该磁盘文件与文件流的关联，原来设置的工作方式也失效，这样，就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联，通过文件流对新的文件进行输入或输出。如
outfile.open("f2.dat",ios::app|ios::nocreate);
3.字符串流的读写
3.1.概念
-
基类：istream，ostream，iostream
-
文件流类：ifstream，ofstream，fstream
-
字符串流类：istrstream，ostrstream，strstream
-
C++11中字符串流类：sstream
向内存中的一个字符数组写数据就如同向文件写数据一样,但有3点不同：
- 1.输出时数据不是流向外存文件，而是流向内存中的一个存储空间。输入时从内存中的存储空间读取数据。在严格的意义上说，这不属于输入输出，称为读写比较合适。 因为输入输出一般指的是在计算机内存与计算机外的文件（外部设备也视为文件）之间 的数据传送。但由于C++的字符串流采用了 C++的流输入输出机制，因此往往也用输入和输出来表述读写操作。
- 2.字符串流对象关联的不是文件,而是内存中的一个字符数组,因此不需要打开和关闭文件。
- 3.每个文件的最后都有一个文件结束符,表示文件的结束。而字符串流所关联的字符数组中没有相应的结束标志,用户要指定一个特殊字符作为结束符,在向字符数组写入全部数据后要写入此字符。
3.2.建立输入输出字符串流对象
(1)将一组数据保存在字符数组中
#include <strstream>
using namespace std;
struct student
{
int num;
char name[20];
float score;
};
int main( )
{
student stud[3]={1001,"Li",78,1002,"Wang",89.5,1004,"Fun",90};
char c[50]; //用户定义的字符数组
ostrstream strout(c,30); //建立输出字符串流,与数组c建立关联,缓冲区长
for(int i=0;i<3;i++) //向字符数组c写个学生的数据
strout<<stud[i].num<<stud[i].name<<stud[i].score;
//strout<<" "<<stud[i].num<<" "<<stud[i].name<<" "<<stud[i].score;
strout<<ends; //ends是C++的I/O操作符,插入一个'\\0'
cout<<"array c:"<<c<<endl; //显示字符数组c中的字符
}
//输出：
//array c:
//1001Li781002Wang89.51004Fun90
(2)在一个字符数组c中存放了50个整数,以空格相间隔,要求将它们放到整型数组中,再按大小排序,然后再存放回字符数组c中
#include <strstream>
using namespace std;
int main( )
{
char c[50]="12 34 65 -23 -32 33 61 99 321 32";
int a[10],i,j,t;
cout<<"array c:"<<c<<endl; //显示字符数组中的字符串
istrstream strin(c,sizeof(c)); //建立输入串流对象strin并与字符数组c关联
for(i=0;i<10;i++)
strin>>a[i]; //从字符数组c读入个整数赋给整型数组a
cout<<"array a:";
for(i=0;i<10;i++)
cout<<a[i]<<" "; //显示整型数组a各元素
cout<<endl;
for(i=0;i<9;i++) //用起泡法对数组a排序
for(j=0;j<9-i;j++)
if(a[j]>a[j+1])
{t=a[j];a[j]=a[j+1];a[j+1]=t;}
ostrstream strout(c,sizeof(c)); //建立输出串流对象strout并与字符数组c关联
for(i=0;i<10;i++)
strout<<a[i]<<" "; //将个整数存放在字符数组c
strout<<ends; //加入'\\0'
cout<<"array c:"<<c<<endl; //显示字符数组c
return 0;
}
//运行结果如下：
//array c: 12 34 65 -23 -32 33 61 99 321 32 (字符数组c原来的内容)
//array a: 12 34 65 -23 -32 33 61 99 321 32 (整型数组a的内容)
//array c: -32 –12 32 33 34 61 65 99 321 (字符数组c最后的内容)
4.OJ.IO练习
#include<iostream>
#include<vector>
#include<string>
using namespace std;
/*
题目描述：输入包括两个正整数a, b(1 <= a, b <= 10 ^ 9), 输入数据包括多组。输出a + b的结果
输入
1 5
10 20
输出
6
30
*/
int CinTwoInt() {
int a, b;
while (cin >> a >> b) {
cout << (a + b) << endl;
}
return 0;
}
/*
题目描述：输入第一行包括一个数据组数t(1 <= t <= 100)，接下来每行包括两个正整数a,b(1 <= a, b <= 10^9).输出a+b的结果。
输入
2
1 5
10 20
输出
6
30
*/
int CinTwoInt2() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
int a, b;
cin >> a >> b;
cout << (a + b) << endl;
}
return 0;
}
/*
题目描述：输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入。输出a+b的结果
输入
1 5
10 20
0 0
输出
6
30
*/
int CinTwoInt3() {
int a, b;
while (cin >> a >> b) {
if (a == 0 && b == 0)
break;
cout << a + b << endl;
}
return 0;
}
/*
计算一系列数的和:输入数据包括多组。
每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。
输出描述:每组数据输出求和的结果
输入
4 1 2 3 4
5 1 2 3 4 5
0
输出
10
15
*/
int CinTwoInt4() {
int numPerArr;//每个数组元素个数
int tmp, sum;
while (cin >> numPerArr) {
sum = 0;
if (numPerArr == 0)
break;
for (int i = 0; i < numPerArr; i++) {
cin >> tmp;
sum += tmp;
}
cout << sum << endl;
}
return 0;
}
/*
计算一系列数的和:输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
输出描述:每组数据输出求和的结果
输入
2
4 1 2 3 4
5 1 2 3 4 5
输出
10
15
*/
int CinTwoInt5() {
int numOfArr;//数组个数
int tmp, sum;
while (cin >> numOfArr) {
for (int i = 0; i < numOfArr; i++) {
int numPerArr;//每个数组元素个数
while (cin >> numPerArr) {
sum = 0;
for (int j = 0; j < numPerArr; j++)
{
cin >> tmp;
sum += tmp;
}
cout << sum << endl;
}
}
}
return 0;
}
/*
计算一系列数的和:输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
输出描述:每组数据输出求和的结果
输入
4 1 2 3 4
5 1 2 3 4 5
输出
10
15
*/
int CinTwoInt6() {
int numPerArr;
int tmp, sum;
while (cin >> numPerArr) {
if (numPerArr == 0)
break;
sum = 0;
for (int i = 0; i < numPerArr; i++) {
cin >> tmp;
sum += tmp;
}
cout << sum << endl;
}
return 0;
}
/*
计算一系列数的和:输入数据有多组, 每行表示一组输入数据。
每行不定有n个整数，空格隔开。(1 <= n <= 100)。
输出描述:每组数据输出求和的结果
输入
1 2 3
4 5
0 0 0 0 0
输出
6
9
0
*/
int CinTwoInt7() {
int tmp, sum;
sum = 0;
while (cin>>tmp) {
sum += tmp;
if (getchar() == '\n') {//这里的getchar平时是空格，所以sum+=tmp不能放后面
cout << sum << endl;
sum = 0;
}
}
return 0;
}
/*
对输入的字符串进行排序后输出:输入有两行，第一行n;第二行是n个空格隔开的字符串
输出描述:输出一行排序后的字符串，空格隔开，无结尾空格
输入
5
c d a bb e
输出
a bb c d e
*/
#include<algorithm>
bool cmp(string a, string b) {
return a > b;
}
void stringSort() {
int numOfStr;
string tmpStr;
vector<string> res;
cin >> numOfStr;
for (int i = 0; i < numOfStr; i++) {
cin >> tmpStr;
res.push_back(tmpStr);
}
//sort(res.begin(), res.end(), cmp);//按照自定义方式比较
sort(res.begin(), res.end());//按照自定义方式比较
for (int i = 0; i < numOfStr; i++) {
if (i == numOfStr - 1) {//结尾无空格
cout << res[i];
break;
}
cout << res[i] << " ";
}
cout << endl;
}
/*
对输入的字符串进行排序后输出:多个测试用例，每个测试用例一行。
每行通过空格隔开，有n个字符，n＜100.
输出描述:对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开
输入
a c bb
f dddd
nowcoder
输出
a bb c
dddd f
nowcoder
*/
void stringSort2() {
string strtmp;
vector<string> res;
while(cin >> strtmp) {
res.push_back(strtmp);
if(cin.get() == '\n') {
sort(res.begin(), res.end());
int num = res.size() - 1;
for(int i = 0; i < num; ++i) {
cout <<res[i] <<' ';
}
cout <<res[num] <<endl;
res.clear();
}
}
return 0;
}
/*
对输入的字符串进行排序后输出:多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100
输出描述:对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格
输入
a,c,bb
f,dddd
nowcoder
输出
a,bb,c
dddd,f
nowcoder
*/
void stringSort3() {
string tmpStr;
vector<string> res;
while (cin >> tmpStr) {//注意这里使用","隔开一个字符串就是一个数组
char* ptr = &tmpStr[0];
string childStr;
res.clear();
while(*ptr != '\0'){
if (*ptr == ',') {
res.push_back(childStr);
childStr.clear();
}
else {
childStr.push_back(*ptr);
}
ptr++;
}
res.push_back(childStr);//最后一次没加入进去，单独添加一次
childStr.clear();
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) {
if (i == res.size() - 1) {//结尾无空格
cout << res[i]<<endl;
continue;
}
cout << res[i] << ",";
}
}
}
#include<string>
int StrSort3(){
// string strtmp;
// vector<string> res;
// 这里是字符串，注释部分均为错误尝试
// while(cin>>strtmp){
// res.push_back(strtmp);
// if(cin.get() == ',')
// continue;
// else if(cin.get() == '\n'){
// sort(res.begin(),res.end());
// int num = res.size();
// for(int i=0; i<num; i++){
// cout<<res[i]<<',';
// }
// cout<<res[num]<<endl;
// res.clear();
// }
// }
// while(getline(cin,strtmp)){
// for(int i = 0; i<sizeof(strtmp); i++){
// string childstr = "";
// if(strtmp[i] == ',' || strtmp[i] == '\0'){
// res.push_back(childstr);
// }else{
// childstr += strtmp[i];
// }
// }
// sort(res.begin(),res.end());
// int num = res.size()-1;
// for(int i=0; i<num; i++){
// cout<<res[i]<<",";
// }
// cout<<res[num];
// res.clear();
// }
string line;
while (getline(cin, line)) {
istringstream sin(line);//istringstream将一个字符串变成了流，这样能被getline使用
string childstr;
vector<string> res;
while (getline(sin, childstr, ',')) {
res.push_back(childstr);
}
sort(res.begin(),res.end());
int num = res.size() - 1;
for(int i = 0; i < num; ++i) {
cout <<res[i] <<',';
}
cout <<res[num] <<'\n';
}
return 0;
}
//int main() {
//
// //CinTwoInt();
// //CinTwoInt2();
// //CinTwoInt3();
// //CinTwoInt4();
// //CinTwoInt5();
// //CinTwoInt6();
// //CinTwoInt7();
// //stringSort();
// //stringSort2();
// stringSort3();
// system("pause");
// return 0;
//}
#define LEN 10
int len_foo() {
int i = 2;
return i;
}
constexpr int len_foo_constexpr() {
return 5;
}
constexpr int fibonacci(const int n) {
return n == 1 || n == 2 ? 1 : fibonacci(n - 1) + fibonacci(n - 2);
}
constexpr int add2num(const int a, const int b) {
return a + b;
}
template<typename T, typename... Ts>
auto pintf3(T value, Ts... args) {
cout << value << endl;
(void)std::initializer_list<T>{ ([&args] {
cout << args << endl;
}(), value)...};
}
template<typename... T>
auto sum(T... t) {
return (t + ...);
}
int main2() {
char arr_1[10];
char arr_2[LEN];//合法
int len = 10;
//char arr_3[len];//非法
const int len_2 = len + 1;
constexpr int len_2_constexpr = 1 + 2 + 3;
//char arr_4[len_2];//非法
char arr_4[len_2_constexpr];//合法
//constexpr int len_3 = len + 1;//非法
int const size1 = 2+3;
char arr_5[size1];
char arr_6[sizeof(int)];
int a = 2;
int b = 3;
char arr_7[add2num(2, 3)];
auto arr = new auto(10);
int* arr1 = new int(10);
cout << sum(1,2.0,3,'m')<<endl;
auto important = std::make_unique<int>(1);
system("pause");
return 0;
}
529
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
