cin 订阅
宫颈上皮内瘤变(CIN)是一组与宫颈浸润癌密切相关的癌前病变的统称。包括宫颈不典型增生和宫颈原位癌,反映了宫颈癌发生中连续发展的过程,即由宫颈不典型增生(轻→中→重)→原位癌→早期浸润癌→浸润癌的一系列病理变化。 展开全文
宫颈上皮内瘤变(CIN)是一组与宫颈浸润癌密切相关的癌前病变的统称。包括宫颈不典型增生和宫颈原位癌,反映了宫颈癌发生中连续发展的过程,即由宫颈不典型增生(轻→中→重)→原位癌→早期浸润癌→浸润癌的一系列病理变化。
信息
就诊科室
妇科
常见病因
人类乳头状瘤病毒,吸烟,微生物感染,内源性与外源性免疫缺陷
常见症状
白带增多,白带带血,接触性出血、宫颈肥大,充血,糜烂,息肉等慢性宫颈炎
英文名称
cervicalintraepithelialneoplasia,CIN
CAD二次开发应用背景
收起全文
精华内容
下载资源
问答
  • C++ cin 详细用法

    万次阅读 多人点赞 2015-09-25 17:24:15
    cin主要用于从标准输入读取数据,这里的标准输入,指的是终端的键盘。此外,cout是流的对象,即ostream类的对象,cerr是标准错误输出流的对象,也是ostream 类的对象。这里的标准输出指的是终端键盘,标准错误输出指...

    代码编译运行环境:VS2017+Win64+Debug。


    1.cin 简介

    cin 是 C++ 的标准输入流对象,即 istream 类的对象。cin 主要用于从标准输入读取数据,这里的标准输入,指的是终端的键盘。此外,cout 是输出流对象,即 ostream 类的对象,cerr 是标准错误输出流的对象,也是 ostream 类的对象。这里的标准输出指的是终端键盘,标准错误输出指的是终端的屏幕。

    在理解 cin 功能时,不得不提标准输入缓冲区。当我们从键盘输入字符串的时候需要敲一下回车键才能够将这个字符串送入到缓冲区中,那么敲入的这个回车键(\r)会被转换为一个换行符(\n),这个换行符也会被存储在 cin 的缓冲区中并且被当成一个字符来计算!比如我们在键盘上敲下了 123456 这个字符串,然后敲一下回车键(\r)将这个字符串送入了缓冲区中,那么此时缓冲区中的字节个数是 7 ,而不是 6。

    cin 读取数据也是从缓冲区中获取数据,缓冲区为空时,cin 的成员函数会阻塞等待数据的到来,一旦缓冲区中有数据,就触发 cin 的成员函数去读取数据。

    2. cin 的常用读取方法

    使用 cin 从标准输入读取数据时,通常用到的方法有 cin>>、cin.get(),cin.getline()。

    2.1 cin>> 的用法

    cin 可以连续从键盘读取想要的数据,以空格、tab 或换行作为分隔符。实例如下。

    #include <iostream>
    using namespace std;
    
    int main() {
    	char a;
    	int b;
    	float c;
    	string 
    	cin>>a>>b>>c;
    	cout<<a<<" "<<b<<" "<<c<<" "<<endl;
    
    	return 0;
    }
    

    在屏幕中一次输入:a[回车]11[回车]5.56[回车],程序将输出如下结果:

    a
    11
    5.56
    a 11 5.56
    

    (1)cin>> 等价于 cin.operator>>(),即调用成员函数 operator>>() 进行读取数据。
    (2)当 cin>> 从缓冲区中读取数据时,若缓冲区中第一个字符是空格、tab或换行这些分隔符时,cin>> 会将其忽略并清除,继续读取下一个字符,若缓冲区为空,则继续等待。但是如果读取成功,字符后面的分隔符是残留在缓冲区的,cin>> 不做处理。
    (3)不想略过空白字符,那就使用 noskipws 流控制。比如 cin>>noskipws>>input;

    验证程序如下:

    #include <string> 
    #include <iostream>
    using namespace std;
    
    int main() {
    	char a;
    	int b;
    	float c;
    	string str;
    	cin>>a>>b>>c>>str;
    	cout<<a<<" "<<b<<" "<<c<<" "<<str<<endl;
    
    	string test;
    	getline(cin,test);	//不阻塞
    	cout<<"test:"<<test<<endl;
    	return 0;
    }
    

    从键盘输入:[回车][回车][回车]a[回车]5[回车]2.33[回车]hello[回车],输出结果是:
    这里写图片描述
    从结果可以看出,cin>> 对缓冲区中的第一个换行符视而不见,采取的措施是忽略清除,继续阻塞等待缓冲区有效数据的到来。但是,getline() 读取数据时,并非像 cin>> 那样忽略第一个换行符,getline() 发现 cin 的缓冲区中有一个残留的换行符,不阻塞请求键盘输入,直接读取,送入目标字符串后,因为读取的内容为空,所以程序中的变量 test 为空串。

    2.2 cin.get() 的用法

    该函数有多种重载形式,分为四种格式:无参,一参数,二参数,三个参数。常用的的函数原型如下:

    int get();
    istream& get(char& var);
    istream& get( char* s, streamsize n );
    istream& get( char* s,  streamsize  n, char delim);
    

    其中 streamsize 在 VC++ 中被定义为 long long 型。另外,还有两个重载形式不怎么使用,就不详述了,函数原型如下:

    istream& get (streambuf& sb);
    istream& get (streambuf& sb, char delim);
    

    2.2.1 cin.get() 读取一个字符

    读取一个字符,可以使用 cin.get() 或者 cin.get(var),示例代码如下:

    #include <iostream>
    using namespace std;
    
    int main() {
    	char a;
    	char b;
    	a=cin.get();
    	cin.get(b);
    	cout << a << b <<endl;
    	return 0;
    }
    

    输入:e[回车],输出:
    这里写图片描述
    (1)从结果可以看出,cin.get() 从输入缓冲区读取单个字符时不忽略分隔符,直接将其读取,就出现了如上情况,将换行符读入变量 b,输出时换行两次,一次是变量 b,一次是 endl。
    (2)cin.get() 的返回值是 int 类型,成功则返回读取字符的 ASCII 码值。
    (3)cin.get(char var) 如果成功返回的是 cin 对象,因此支持链式操作,如cin.get(b).get(c)

    2.2.2 cin.get() 读取一行

    读取一行可以使用:

    istream& get(char* s, streamsize n)
    istream& get(char* s, size_t n, streamsize  delim)
    

    二者的区别是前者默认以换行符结束,后者可指定行结束符。n 表示目标空间的大小。

    示例代码如下:

    #include <iostream>
    using namespace std;
    
    int main() {
    	char a;
    	char array[20]={NULL}; 
    	cin.get(array,20);
    	cin.get(a);
    	cout<<array<<" "<<(int)a<<endl;
    	return 0;
    }
    

    输入:123456789[回车],输出:

    123456789
    123456789 10
    

    (1)从结果可以看出,cin.get(array,20); 读取一行时,遇到换行符时结束读取,但是不对换行符进行处理,换行符仍然残留在输入缓冲区。第二次由 cin.get() 将换行符读入变量 b,打印输入换行符的 ASCII 码值 10。这也是 cin.get() 读取一行与使用 cin.getline 读取一行的区别所在。cin.getline 读取一行字符时,默认遇到 ‘\n’ 时终止,并且将 ‘\n’ 直接从输入缓冲区中删除掉,不会影响下面的输入处理。

    (2)cin.get(str,size); 读取一行时,只能将字符串读入 C 风格的字符串中,即 char*,但是 cin.getline() 函数可以将字符串读入C++ 风格的字符串 string中。鉴于 cin.getline() 较 cin.get() 的这两种优点,建议使用 cin.getline() 读取行。

    2.3 cin.getline() 读取一行

    函数作用:从标准输入设备键盘读取一串字符串,并以指定的结束符结束。
    函数原型有两个:

    istream& getline(char* s, streamsize count); //默认以换行符结束
    istream& getline(char* s, streamsize count, char delim);
    

    使用示例:

    #include <iostream>
    using namespace std;
    
    int main() {
    	char array[20]={NULL};
    	cin.getline(array,20); //或者指定结束符,使用下面一行
    	//cin.getline(array,20,'\n');
    	cout<<array<<endl;
    	return 0;
    }
    

    注意,cin.getline() 与 cin.get() 的区别是,cin.getline() 不会将行结束符(如换行符)残留在输入缓冲区中。

    3. cin 的条件状态

    使用 cin 读取键盘输入时,难免发生错误,一旦出错,cin 将设置条件状态(condition state)。条件状态位有:

    goodbit(0x0):无错误
    eofbit(0x1):已到达文件尾
    failbit(0x2):非致命的输入/输出错误,可挽回
    badbit(0x4):致命的输入/输出错误,无法挽回
    

    与这些条件状态对应的就是设置、读取和判断条件状态的流对象的成员函数。它们主要有:

    s.eof():若流 s 的 eofbit 置位,则返回 true
    s.fail():若流 s 的 failbit 置位,则返回 true
    s.bad():若流 s 的 badbit 置位,则返回 true
    s.good():若流 s 的 goodbit 置位,则返回 true
    s.clear(flags):清空当前状态, 然后把状态设置为 flags,返回 void
    s.setstate(flags):不清空当前状态,设置给定的状态 flags,返回 void
    s.rdstate():返回流 s 的当前条件状态,返回值类型为 ios_base::iostate
    

    了解以上关于输入流的条件状态与相关操作函数,下面看一个因输入缓冲区未读取完造成的状态位 failbit 被置位,再通过 clear()复位的例子。

    #include <iostream>
    using namespace std;
    
    int main() {
    	char ch, str[20]; 
    	cin.getline(str, 5);
    	cout<<"goodbit:"<<cin.good()<<endl;    // 查看goodbit状态,即是否有异常
    	cin.clear();                         // 清除错误标志
    	cout<<"goodbit:"<<cin.good()<<endl;    // 清除标志后再查看异常状态
    	cin>>ch; 
    	cout<<"str:"<<str<<endl;
    	cout<<"ch:"<<ch<<endl;
    	return 0;
    }
    

    输入:12345[回车],输出结果为:

    12345
    goodbit:0
    goodbit:1
    str:1234
    ch:5
    

    可以看出,因输入缓冲区未读取完造成输入异常,通过 clear() 可以清除输入流对象cin的异常状态。,不影响后面的cin>>ch从输入缓冲区读取数据。因为cin.getline读取之后,输入缓冲区中残留的字符串是:5[换行],所以 cin>>ch 将 5 读取并存入 ch,打印输入并输出 5。

    如果将 clear() 注释,cin>>ch; 将读取失败,ch 为空。cin.clear() 等同于 cin.clear(ios::goodbit); 因为 cin.clear() 的默认参数是 ios::goodbit,所以不需显示传递,故而你最常看到的就是 cin.clear()。

    4. cin 清空输入缓冲区

    从上文中可以看出,上一次的输入操作很有可能是输入缓冲区中残留数据,影响下一次输入。那么如何解决这个问题呢?自然而然,我们想到了在进行输入时,对输入缓冲区进行清空和状态条件的复位。条件状态的复位使用 clear(),清空输入缓冲区应该使用 cin.ignore()。

    函数原型:

    istream &ignore(streamsize num=1, int delim=EOF);
    

    函数作用:跳过输入流中 n 个字符,或在遇到指定的终止字符时提前结束(此时跳过包括终止字符在内的若干字符)。

    使用示例如下:

    #include <iostream>
    using namespace std;
    
    int main() {
    	char str1[20]={NULL},str2[20]={NULL};
        cin.getline(str1,5);
        cin.clear();  // 清除错误标志
    	cin.ignore(numeric_limits<std::streamsize>::max(),'\n'); // 清除缓冲区的当前行
    	cin.getline(str2,20);
    	cout<<"str1:"<<str1<<endl;
    	cout<<"str2:"<<str2<<endl;
    	return 0;
    }
    

    程序输入:12345[回车]success[回车],程序输出:

    12345
    success
    str1:1234
    str2:success
    

    (1)程序中使用 cin.ignore 清空了输入缓冲区的当前行,使上次的输入残留下的数据没有影响到下一次的输入,这就是 ignore() 函数的主要作用。其中,numeric_limits<std::streamsize>::max()<limits>头文件定义的流使用的最大值,你也可以用一个足够大的整数代替它。如果想清空输入缓冲区的所有内容,去掉换行符即可:

    cin.ignore(numeric_limits< std::streamsize>::max());
    

    这里要注意的是,如果缓冲区中没有 EOF(-1),cin.ignore() 会阻塞等待。如果在命令行,我们可以使用 Ctrl+Z 然后回车(Windows 命令行)或直接 Ctrl+D(Linux 命令行)输入 EOF。

    (2)cin.ignore();当输入缓冲区没有数据时,也会阻塞等待数据的到来。

    (3)请不要使用 cin.sync() 来清空输入缓冲区,本人测试了一下,VC++ 和 GNU C++ 都不行,请使用 cin.ignore()。

    5.从标准输入读取一行字符串的其它方法

    5.1 getline() 读取一行

    C++ 中定义了一个在 std 名字空间的全局函数 getline(),因为这个 getline() 函数的参数使用了 string 字符串,所以声明在了<string>头文件中了。

    getline() 利用 cin 可以从标准输入设备键盘读取一行,当遇到如下三种情况会结束读操作:
    (1)文件结束;
    (2)遇到行分隔符;
    (3)输入达到最大限度。

    函数原型有两个重载形式:

    istream& getline ( istream& is, string& str);						//默认以换行符\n分隔行
    istream& getline ( istream& is, string& str, char delim);
    

    使用示例:

    #include <string> 
    #include <iostream>
    using namespace std;
    
    int main()
    {
    	string str;
    	getline(cin,str);
    	cout << str << endl;
    	return 0;
    }
    

    输入:hello world[回车],输出:

    hello world
    hello world
    

    注意,getline() 遇到结束符时,会将结束符一并读入指定的 string 中,再将结束符替换为空字符。因此,进行从键盘读取一行字符时,建议使用 getline,较为安全。但是,最好还是要进行标准输入的安全检查,提高程序容错能力。

    cin.getline() 与 getline() 类似,但是因为 cin.getline() 的输出是char*,getline() 的输出是 string,所以 cin.getline() 属于 istream 流,而 getline() 属于 string 流,二者是不一样的函数。

    5.2 gets() 读取一行

    gets() 是 C 中的库函数,在头文件 <stdio.h> 申明,从标准输入设备读字符串,可以无限读取,不会判断上限,以回车或者文件结束符 EOF( 即 -1) 结束,所以程序员应该确保 buffer 的空间足够大,以便在执行读操作时不发生溢出。Windows 下命令行输入文件结束符 EOF 的方式为 Ctrl+z,Linux 为 Ctrl+d。

    函数原型:

    char *gets(char *buffer);
    

    使用示例:

    #include <iostream>
    using namespace std;
    int main()
    {
    	char array[20]={NULL};
    	gets(array);
    	cout << array << endl;
    	return 0;
    }
    

    输入:I am lvlv[回车],输出:

    I am lvlv
    I am lvlv
    

    由于该函数是 C 的库函数,所以不建议使用,既然是 C++ 程序,就尽量使用 C++ 的库函数吧。


    参考文献

    [1] C++ primer
    [2] 百度百科.gets
    [3] Cin详解
    [4] 关于C++中cin.ignore()的问题
    [5] 标准输入缓冲区的个人理解,望指点!
    [6] C++ referfence.istream

    展开全文
  • cin

    2017-09-18 21:31:17
    第一次搞cin,真是搞昏人了,现在逐渐开始明白是什么东东,一起探讨一下吧!  首先大家要知道cin是怎么一回事,为什么要有? 在C中,输入输出要用printf和scanf,这是2个很麻烦的东西,因为在输入数据的同时还要说明...
    第一次搞cin,真是搞昏人了,现在逐渐开始明白是什么东东,一起探讨一下吧! 
    首先大家要知道cin是怎么一回事,为什么要有?


    在C中,输入输出要用printf和scanf,这是2个很麻烦的东西,因为在输入数据的同时还要说明数据的类型,如果输入数据较多,那就很麻烦了,所以我们的C++搞了两个更爽的东西cout和cin,来替换它们.首先我们先了解一下这两个东西的来处,它们是来自C++的一个类库叫 " iostream".
    iostream是由istream(输入类)和ostream(输出类)派生.所以在iostream中就有了输入和输出的相关对象:
    1,cin,表示标准输入(standard input)的istream类对象.cin使我们可以从设备读取数据.
    2,cout,表示标准输出(standard output)的ostream类对象.cout使我们可以向设备输出或者写数据.
    3,cerr(暂时还没试过,先别理吧)
    暂时先介绍那么多,这里我主要想说的是cin.get()和cin.getline(),cin.clear(),cin.sync()等的用法.


    首先看看cin.get(),它是一个读取单个字符的方法.


    字符变量=cin.get();相当于cin.get(字符变量);


    #include <iostream> 
    using namespace std; 


    int main() 

            char cstr;
             cstr=cin.get();          //读取单个字符,在屏幕输入,也相当于cin.get(cstr);
             cout<<cstr<<endl;  //输出刚刚载入的单个字符
            system("pause"); 
    }


    运行程序后,一切正常:
    输入:a    输出:a


    但当我们输入的不只一个英文字符时,那又会如何呢?
    输入:abcd         输出:a


    由此可知,它只能读取第一个字符,但如果我们把程序修改成:


    int main() 

            char cstr;
            char bstr;
             cstr=cin.get();        //读取单个字符,在屏幕输入
            bstr=cin.get();  
             cout<<cstr<<bstr<<endl;  //输出刚刚载入的单个字符
            system("pause"); 
    }


    我们再输入:abcd    最后输出了:ab
    既然cin.get()是读取第一个字符,那bstr为什么不也是a呢?
    其实原理是这样的:
    在cin这个对象里,有一个储存字符的流,可以想象成缓冲区,但事实上是cin里封装的一个东西.当我们在程序上输入字符后,对象cin获得了我们输入的字符,例如获得abcd,然后再通过.get()把流里面的第一个字符去掉,赋给cstr,这时,cin里储存的流的数据为bcd,而cstr则获得了a.当我们再次运行bstr=cin.get();时,同理把cin里流的数据的b拿出来给了bstr,此后,cin里面的流的数据为cd,而bstr则为b,所以最后输出时,便能输出ab了.


    还有个补充,究竟什么时候才输入数据呢?我们可以再通过上面的代码进行尝试,我们输入单个字母'a',然后按回车,发现并没有输出数据,而是再等待一次输入数据,我们再输入字母'b',按回车后便输出ab了.相信到这里,大家都应该明白了,因为当我们第一次输入a后,通过cstr=cin.get();使cin里的流没有数据,清空了.所以到第二次要再赋给bstr值时,它找不到数据,要重新再输入数据.由此来看可以知道,当cin里的流数据清空时,便需要重新输入才能赋值.而cin.get()还有个用法:


    int main() 

            char cstr;
            char bstr;
             cstr=cin.get();        //读取单个字符,在屏幕输入
            cin.get();
            bstr=cin.get();  
             cout<<cstr<<bstr<<endl;  //输出刚刚载入的单个字符
            system("pause"); 
    }


    程序中有3个cin.get(),所以我们尝试输入:abc.   发现输出了:ac
    由此能知道,当空回调cin.get();时,cin.get便自动在cin中的流数据中删除一个字母,起了一个删除作用.


    对cin.get()有了一定了解之后,对cin.getline()的学习就可以更快了,原理是一致的,但是cin.getline()则是获取一整行文本.以下是cin.getline()原形:
    getline(char *line,int size,char='/n')
    第一个就是字符指针,第二个是字符长度,第三个1行的结束标识符.


    int main() 

            char cstr[200];
            cin.getline(cstr,sizeof(str));     //第三个参数不输入,默认回车为结束标识符
             cout<<cstr<<endl;                //输出
            system("pause"); 
    }


    这样我们输入一堆英文或数字,然后按回车,就会输出一行刚刚输出的东西了.接下来.我们讨论第三个参数的作用.


    int main() 

            char cstr[200];
            cin.getline(cstr,sizeof(str),'X');     //我们以单个英文字母'X'作为终止标识符
             cout<<cstr<<endl;                     //输出
            system("pause"); 
    }


    当我们输入一大堆东西,例如
    输入: kkkkkkk(回车)              输出: kkkkkkk(回车)                        
               bbbbbbb(回车)                     bbbbbbb(回车)       
               lllllX                                          lllll


    这样X便成了终止符,其原理和cin.get一样.或许我们可以像cin.get那样尝试一下:


    int main() 

            char cstr[200];
            char bstr[200];
            cin.getline(cstr,sizeof(str),'X');     //我们以单个英文字母'X'作为终止标识符
            cin.getline(bstr,sizeof(btr),'a');
             cout<<"第一行是:"<<cstr<<endl;                     //输出
            cout<<"第二行是:"<<bstr<<endl;  
            system("pause"); 
    }


    我们输入:kkkkkkkkk(回车)                                        输出:第一行是:kkkkkkkkk(回车) 
                     oooooooooX(回车)                                                              ooooooooo(回车)
                     bbbbbbbbba(回车)                                                第二行是:(回车)
                                                                                                                   bbbbbbbbb


    在这里,我在不厌其烦地说一下原理,如果刚刚cin.get()原理看懂的可以跳过.
    首先,我们第一次getline会把X前面的字符赋给cstr,然后从cin里的数据流删除,标识符X也删除了,所以输出的cstr如上所示.当我们第二次运行getline时,此时cin里的数据流为(回车)bbbbbbbbba,回车也是一个字符,事实上在数据流里用"/n"表示,接着就按照原来第一次的方法,把标识符'a'前面的字符赋给bstr,然后再删除字符号及标识符.所以输出结果如上.


    接下来我们谈谈cin.clear的作用,第一次看到这东西,很多人以为就是清空cin里面的数据流,而实际上却与此相差很远,首先我们看看以下代码:


    #include <iostream> 
    using namespace std; 


    int main() 

            int a; 
            cin>>a; 
            cout<<cin.rdstate()<<endl; 
            if(cin.rdstate() == ios::goodbit)
    {
    cout<<"输入数据的类型正确,无错误!"<<endl; 
                 } 
            if(cin.rdstate() == ios_base::failbit) 
            { 
                    cout<<"输入数据类型错误,非致命错误,可清除输入缓冲区挽回!"<<endl; 
            } 
            system("pause"); 
    }


    我们定义要输入到的变量是整型,但如果我们输入了英文字母或者汉字,那就会发生错误,cin里有个方法能检测这个错误,就是cin.rdstate();
    当cin.rdstate()返回0(即ios::goodbit)时表示无错误,可以继续输入或者操作,若返回4则发生非致命错误即ios::failbit,则不能继续输入或操作.而cin.clear则可以控制我们此时cin里对这个问题的一个标识.语发如下:
    cin.clear(标识符);
    标识符号为:


    goodbit 无错误
    Eofbit 已到达文件尾
    failbit 非致命的输入/输出错误,可挽回
    badbit 致命的输入/输出错误,无法挽回 
    若在输入输出类里.需要加ios::标识符号
    通过cin.clear,我们能确认它的内部标识符,如果输入错误则能重新输入.结合真正的清空数据流方法cin.sync(),请看下例:


    #include <iostream> 
    using namespace std; 


    int main() 

            int a; 
            while(1) 
            { 
                    cin>>a; 
                    if(!cin)            //条件可改写为cin.fail() 
                    { 
                            cout<<"输入有错!请重新输入"<<endl; 
                            cin.clear(); 
                             cin.sync();   //清空流
                    } 
                    else 
                    { 
                            cout<<a; 
                            break; 
                    } 
            } 
            system("pause"); 
    }


    上面的cin默认参数为0,即无错误,正常操作.当我们输入英文字母'k'时,它的状态标识改为fail(即1),即错误,用cout对用户输出信息,再用cin.clear让错误标识改回为0,让我们可以继续输入,再清空流数据继续输入.如果我们没有了cin.clear,则会进入死循环,其过程为我们输入了英文字母,它的状态标识便为fail,当运行到条件判断时,便总是回到错误的条件表示里,并且我们再也没办法输入,因为错误的表示关闭了cin,所以会进入死循环.


    ---------------------------------------------------------------------


    自己再添加一句:如果输入错误,则再也输入不进去,须用clear.而sync用于清除当前输入缓冲区中的内容。



    #include <iostream>


    int main()
    {
     using namespace std;
        
     int a; 
     cin >> a;
     cout << a <<endl;
     cin >> a ;
     cout <<a <<endl;
     cin.clear();
     cin.sync();  // 可以将cin.clear();cin.sync();  不同时注释掉试一下就知道了
     cin >> a;
     cout <<a <<endl;


    return 0;


    }
    展开全文
  • cincin.get()、cin.getline()、getline()的区别

    万次阅读 多人点赞 2018-05-14 15:51:30
    测试平台g++ 5.4.0和VS2015社区版。...正因为cin函数是直接从缓冲区取数据的,所以有时候当缓冲区中有残留数据时,cin函数会直接取得这些残留数据而不会请求键盘输入。 比如下面的例子: voidtest_i...

    测试平台g++ 5.4.0和VS2015社区版。

    输入原理简述:

    程序的输入都建有一个缓冲区,即输入缓冲区。每次输入过程是这样的,当一次键盘输入结束时会将输入的数据存入输入缓冲区,而cin函数直接从输入缓冲区中取数据(cin读取数据是从第一个非空白字符开始到下一个空白字符结束)。正因为cin函数是直接从缓冲区取数据的,所以有时候当缓冲区中有残留数据时,cin函数会直接取得这些残留数据而不会请求键盘输入。

      比如下面的例子:

    void test_input()  
    {  
        string str;  
        cout<<"cin的测试:"<<endl;  
        cin>>str;  
        cout<<str<<endl;  
        cin>>str;  
        cout<<str<<endl;  
    }  


            由于cin在遇到空格/tab时,就会停止读取,所以如果我在第一次输入时,利用空格隔开两个字符串,那么cin在第一次取的时候,只会读取前一个字符串,到空格结束,此时缓冲区还保留着前面输入的第二个字符串,那么第二次cin就会直接从缓冲区取残留数据,而不会请求输入。

           当然对于以上的情况,也有解决的方案,那就是在第二次调用cin>>str之前通过cin.sync()来清空输入缓冲区,看一下下面的例子,此处不赘述:

    void test_input()  
    {  
        string str;  
        cout<<"cin的测试:"<<endl;  
        cin>>str;  
        cin.sync();  
        cout<<str<<endl;  
        cin>>str;  
        cout<<str<<endl;  
    }  


      各种输入方法简介:

            1、cin>>

            根据cin>>sth 中sth的变量类型读取数据,这里变量类型可以为int,float,char,char*,string等诸多类型。这一输入操作,在遇到结束符(Space、Tab、Enter)就结束,且对于结束符,并不保存到变量中。注意:最后一个enter也在缓冲区。

    void test_input()  
    {  
        char ch;
        char ch1[10],ch2[10];  
        cout<<"输入两个字符串:"<<endl;  
        cin>>ch1;  
        cin>>ch2;  
        cout<<"两个字符串分别为:"<<endl;  
        cout<<ch1<<endl;  
        cout<<ch2<<endl;  
        cin.get(ch);
        cout << (int)ch << endl; //输出10,为最后一个enter输入
    }  


    2、cin.get(字符数组名,接收长度,结束符)

    其中结束符意味着遇到该符号结束字符串读取,默认为enter,读取的字符个数最多为(长度 - 1),因为最后一个为'\0'。要注意的是,cin.get(字符数组名,接收长度,结束符)操作遇到结束符停止读取,但并不会将结束符从缓冲区丢弃。cin.get函数有如下几种声明:

    int get();
    istream& get(char& c);
    istream& get(char* s, streamsize n);
    istream& get(char* s, streamsize n, char delim);
    istream& get(streambuf& sb);
    istream& get(streambuf& sb, char delim);

    (1)接收一个字符ch=cin.get()或cin.get(char ch),二者等价,看两个例子

    cin.get()存在的基本目的,我认为就是为了从c移植到c++的时候,直接用cin.get()代替getchar(),也正因因此,cin.get()的返回值跟其它cin.get成员函数返回cin对象不同,跟getchar()一样返回int。所以cin.get()和C语言的getchar()没什么区别。

     

    void test_input()  
    {  
        char ch1,ch2;  
        cout<<"请输入两个字符:"<<endl;  
        cin.get(ch1);//或ch1 = cin.get();  
        cin.get(ch2);  
        cout<<ch1<<" "<<ch2<<endl;  
        cout<<(int)ch1<<" "<<(int)ch2<<endl;  
    }  
    

    来看几组测试:

    • 连续输入ab[enter],结果正常,ch1,ch2分别读取了a、b,将其输出,然后在输出其ASCII值。要注意的是,以上输入并读取后,缓冲区中依然存在[Enter]没有被删除。

     

    • 输入a[Space]b[Enter],结果在输出时,只看到了a,输出ASCII值时候分别为97 32(空格的ASCII值),这就说明cin.get()并不会舍弃Space,依然会将其读取进去,并加以显示等操作。 

     

    • 输入a[Enter],输出见下图。在输出a之后,第二次的输出产生了换行的效果,而输出的第二个ASCII值为10(Enter的ASCII值),这就进一步响应了前面说到的cin.get()遇到结束符并不会将之删除。  

     

    (2)接收一定长度的字符串cin.get(字符数组名,接收长度,结束符),结束符为可选参数,默认为Enter,可以接受Space 、Tab,对于结束符的处理要注意,结束符并不会丢掉,同样看几个例子。

    • 对于如下代码,所做的操作时,在不遇到enter时最多读入(6-1)=5个字符到ch2中,然后读入下一个字符到ch1中,显示ch2,ch1以及其ASCII码值。附上几组测试:  
    void test_input()  
    {  
        char ch1,ch2[10];  
        cout<<"请输入字符串:"<<endl;  
        cin.get(ch2,6);//在不遇到结束符的情况下,最多可接收6-1=5个字符到ch2中,注意结束符为默认Enter  
        cin.get(ch1);//或ch1 = cin.get();  
        cout<<ch2<<endl;  
        cout<<ch1<<"\n"<<(int)ch1<<endl;  
    }  

     

    • 输入:zifuchuan[Enter],由于输入长度大于(6-1)=5,所以会首先读入“zifuc”到ch1,此时“huan”仍在缓冲区,当执行cin.get(ch1)会直接从缓冲区读入h,而不需要申请从键盘输入,看一下结果,符合分析。

    • 输入:zifu[Enter],此时输入长度小于5就遇到了默认结束符Enter,则ch2中只读入“zifu”,要注意的是,输入缓冲区里面的Enter还在,所以接下来要读入的ch1的内容将是Enter,而输出时将看到换行,ASCII码值为10,见下图

    • 输入:zi fuchuan[Enter],注意中间的空格,cin.get()对空格并不敏感,依然会读入,故而ch2读入的是“zi fu”,ch1读入的是c

    假如:

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	char ch1, ch2[10];
    	cout << "请输入字符串:" << endl;
    	cin.get(ch2, 13);//在不遇到结束符的情况下,最多可接收13-1=12个字符到ch2中,注意结束符为默认Enter  
    	cin.get(ch1);//或ch1 = cin.get();  
    	cout << ch2 << endl;
    	cout << ch1 << "\n" << (int)ch1 << endl;
    	
    	return 0;
    }

    输入:123456789(enter)

    输出:

    输入:1234567890(enter)

    则VS2015运行报错!因为ch2[10]用cin.get最多接受9个字符,最后一个是'\0'。但g++ 5.4.0正常(说明没有对下标越界做检查)。

     

    还有一点需要注意的是,cin.get(字符数组名,接收长度,结束符),当一开始第一个输入字符(即前面无其他任何字符)就遇到结束符情况下,将不会正常输出,但缓冲区中依然有该结束符。

    例:

    #include <iostream>
    using namespace std;
    
    int main()
    {	
    	char ch[5], ch2;	
    	cin.get(ch, 3); //默认结束符'\n',此处直接(enter)
    	cin.get(ch2);
    	cout << ch2 << ' ' << (int)ch2 << endl; //VS2015 输出-52, g++ 5.4.0 输出0
    	
    	return 0;	
    }

    以上程序如果输入1(enter),将正常输出\n的ASCII码,输出如下:

     

    清除错误标志:

    #include <iostream> 
    using namespace std;
    
    int main()
    {
    	char ch[5], ch2;
    	cin.get(ch, 3); //默认结束符'\n',此处直接(enter)
    	cin.clear(); //清除错误标志
    	cin.get(ch2); 
    	cout << ch2 << ' ' << (int)ch2 << endl;
    
    	return 0;
    }
    

    输出:

    可见结束符依然在缓冲区当中。

    再来一例:

    #include <iostream>
    using namespace std;
    
    int main()
    {	
    	char ch[5], ch2;	
    	cin.get(ch, 3, 'a');// 结束符为'a',直接输入a(enter)
    	cin.get(ch2);
    	cout << ch2 << ' ' << (int)ch2 << endl;
    	
    	return 0;	
    }
    	

    输出:

    如果输入1a(enter),输出如下:

     

    清除错误标志:

    #include <iostream> 
    using namespace std;
    
    int main()
    {
    	char ch[5], ch2;
    	cin.get(ch, 3, 'a');// 结束符为'a',直接输入a(enter)
    	cin.clear(); // 清除错误标志
    	cin.get(ch2);
    	cout << ch2 << ' ' << (int)ch2 << endl;
    
    	return 0;
    }
    
    

    输出:

    可见结束符'a'依然在缓冲区当中。

     

    补充:cin.get(ch2)和ch2 = cin.get()小区别:

    #include <iostream>
    using namespace std;
    
    int main()
    {	
    	char ch[5], ch2;	
    	cin.get(ch, 3, 'a'); //此处输入a(enter)
    	ch2 = cin.get(); //注意与cin.get(ch2)不同
    	cout << ch2 << ' ' << (int)ch2 << endl;
    	
    	return 0;	
    }

     

    (3)cin.get( ),注意此时没有参数,可用于舍弃输入流中的不需要的字符,或者舍弃回车,弥补cin.get(字符数组名,字符数目,结束符)的不足。对(2)中的代码加入一句话cin.get()如下:

    void test_input()  
    {  
        char ch1,ch2[10];  
        cout<<"请输入字符串:"<<endl;  
        cin.get(ch2,6);//在不遇到结束符的情况下,最多可接收6-1=5个字符到ch2中  
        cin.get();//注意:前面两句可以写到一块:cin.get(ch2,6).get();  
        cin.get(ch1);//或ch1 = cin.get();  
        cout<<ch2<<endl;  
        cout<<ch1<<"\n"<<(int)ch1<<endl;  
    }  
    • 前面遇到的一个状况是,输入字符后,其结束符(如默认的Enter)会保留在缓冲区中,当下次读入时,又会再读入,此时就可以用到cin.get()读掉输入缓冲区不需要的字符,如:输入:zi[Enter],由于遇到结束符,所以ch2内容为zi,此时输入缓冲区还存在着[Enter],但cin.get()将其舍弃掉之后,cin.get(ch1)就会申请从键盘输入内容,如下所示:

    3、cin.getline(字符数组名,接收长度,结束符)

    其用法与cin.get(字符数组名,接收长度,结束符)极为类似。cin.get()当输入的字符串超长时,不会引起cin函数的错误,后面若有cin操作,会继续执行,只是直接从缓冲区中取数据。但是cin.getline()当输入超长时,会引起cin函数的错误,后面的cin操作将不再执行。如下代码:

    1. void test_input()  
      {  
          char ch1,ch2[10];  
          cout<<"请输入字符串:"<<endl;  
          cin.getline(ch2,6);//在不遇到结束符的情况下,最多可接收6-1=5个字符到ch2中  
          cin>>ch1;  
          cout<<ch2<<endl;  
          cout<<ch1<<"\n"<<(int)ch1<<endl;  
      }  

       

    •  测试:如下图,输入zifuchuan[Enter],长度大于最大长度5,就会导致cin函数错误,其后既没有像cin.get()一样直接从输入缓冲区直接读数据,也没有从键盘输入。所以此处可以注意,考虑在用cin.getline()时,适度设置其最大接受长度大一点。
    • 假如:
      #include <iostream>
      using namespace std;
      
      int main()
      {
      	char ch1, ch2[6]; // 最多可接收5个,最后一个'\0'
      	cout << "请输入字符串:" << endl;
      	cin.getline(ch2, 8);//在不遇到结束符的情况下,最多可接收8-1=7个字符到ch2中  
      	cin >> ch1;
      	cout << ch2 << endl;
      	cout << ch1 << "\n" << (int)ch1 << endl;
      
      	return 0;
      }

      输入:123456(enter)     VS将会报错,g++正常。说明VS对数组下标进行了检查。

    • cin.get()每次读取一整行并把由Enter键生成的换行符留在输入队列中,然而cin.getline()每次读取一整行并把由Enter键生成的换行符抛弃,比如:
    • #include <iostream>
      using namespace std;
      
      int main() {
      	cout << "Enter your name:";
      	char name[15];
      	//cin.get(name, 15);
      	cin.getline(name, 15);// 输入abc(enter)
      	cout << "name:" << name << endl;
      	char ch;
      	cin.get(ch);// 输入123(enter) 注:因为cin.getline把最后一个换行符丢弃了,所以此处ch读取字符'1'
      	cout << (int)ch << endl;  //输出49  '1'的ASCII码值
      	cout << "\nEnter your address:";
      	char address[15];
      	//cin.getline(address, 15);
      	cin.get(address, 15); //直接读取缓冲区剩余的23 注:cin.get保留最后一个换行符在缓冲区
      	cout << "address:" << address << endl;	
      	cin.get(ch); // 读取缓冲区最后一个换行符
      	cout << (int)ch << endl;
      	cin.get(ch);  // 缓冲区已为空,所以从键盘输入a
      	cout << (int)ch << endl; //输出97  'a'的ASCII码值
      	return 0;
      }

     

    #include <iostream>
    using namespace std;
    
    int main() {
    	cout << "Enter your name:";
    	char name[15];
    	cin.get(name, 15); // 输入abc(enter)
    	//cin.getline(name, 15);
    	cout << "name:" << name << endl;
    	char ch;
    	cin.get(ch); //因为cin.get不会丢弃最后一个换行符,所以此处ch读取换行符
    	cout << (int)ch << endl; //输出10  '\n'的ASCII码值
    	cout << "\nEnter your address:";
    	char address[15];
    	cin.getline(address, 15); //输入123(enter)
    	//cin.get(address, 15);
    	cout << "address:" << address << endl;	
    	cin.get(ch);// 因为cin.getline丢弃最后一个换行符,所以此处重新从键盘输入a(enter)
    	cout << (int)ch << endl; //输出97 'a'的ASCII码值
    	cin.get(ch);   // cin.get不会丢弃最后一个换行符,所以此处读取上一步输入的保留在缓冲区的换行符
    	cout << (int)ch << endl; // 输出10 '\n'的ASCII码值
    	return 0;
    }

     

     

    4、getline(istream is,string str,结束符)

    同样,此处结束符为可选参数(默认依然为enter)。然而,getline()与前面的诸多存在的差别在于,它string库函数下,而非前面的istream流,所有调用前要在前面加入#include<string>。与之对应这一方法读入时第二个参数为string类型,而不再是char*,要注意区别。另外,该方法也不是遇到空白字符(tab, space, enter(当结束符不是默认enter时))就结束输入的,且会丢弃最后一个换行符。

    #include <iostream>
    #include <string>
    using namespace std;
    
    int main() {
    	char ch;
    	string str;
    	cout << "请输入string内容:" << endl;
    	getline(cin, str); //输入:abc(space)(space)d(enter)
    	//getline(cin, str, 'a');	
    	cout << str << endl;
    	cin.get(ch); //因为丢弃了最后一个换行符,所以此处从键盘输入b
    	cout << (int)ch << endl; //输出:98 'b'的ASCII码值
    	return 0;
    }

    #include <iostream>
    #include <string>
    using namespace std;
    
    int main() {
    	char ch;
    	string str;
    	cout << "请输入string内容:" << endl;
    	//getline(cin, str);
    	getline(cin, str, 'a');	//输入:string(enter)strinabc,遇到结束符'a'停止读取
    	cout << str << endl; //输出string(enter)strin
    	cin.get(ch); //将缓冲区中'a'丢弃,读取'a'之后的'b'
    	cout << (int)ch << endl; //输出:98 'b'的ASCII码值
    	return 0;
    }

    
     

    5、getline和cin.getline区别

    cin.getline()当输入超长时,会引起cin函数的错误,后面的cin操作将不再执行。

    #include <iostream>  
    using namespace std;
    
    int main()
    {
    	char ch, a[20];
    	cin.getline(a, 5);// 此处输入12345(enter)
    	cin >> ch;
    	cout << a << endl;
    	cout << (int)ch << endl;
    	return 0;
    }

    输出:

    这里的ch并没有读取缓冲区中的5,而是返回了-52(VS)/0(g++),这里其实cin>>ch语句没有执行,是因为cin出错了!我们经常会看到程序中会出现cin.clear(),cin.ignore(), cin.fail()等函数。这些函数都是与cin的错误处理有关的。这一节我们来分析一下cin的错误处理机制,并且学习几个重要的函数:cin.fail(), cin.bad(), cin.good(), cin.clear(), cin.ignore()等。程序执行时有一个标志变量来标志输入的异常状态,其中有三位标志位分别用来标志三种异常信息,他们分别是:failbit,eofbit,badbit。

    ios类定义了这四个常量badbit, eofbit, failbit, goodbit,其实这四个标志常量就是取对应标志位的掩码,也即输入的四种异常情况!

     

    以上四个常量在g++对应的取值为:
    ios::badbit    001   输入(输出)流出现致命错误,不可挽回 
    ios::eofbit    010   已经到达文件尾
    ios::failbit   100   输入(输出)流出现非致命错误,可挽回 
    ios::goodbit   000   流状态完全正常, 各异常标志位都为0

    我们可以用输出语句来验证这几个常量的值:
    cout << ios:: failbit << endl;
    cout << ios:: eofbit << endl;
    cout << ios:: badbit << endl; 
    cout << ios:: goodbit << endl;
    g++输出的结果为:

     

    VS下输出:

    【注意】它们不是failbit、badbit、eofbit、goodbit这四个标记位的存贮变量,而是四个标志四种异常状态的常量,其实他们就相当于取对应状态标志位的掩码。如果标志变量为flag,则flag & failbit 就取得fail标志位。

     

    搞清楚了标志位的原理后,我们来看几个关于异常标志的函数:

    1、iostate ios::rdstate()
    取标志变量的值,我们可以用该函数取得整个标志变量的值,再与前面定义的标志位常量相与就可以获得对应标志位的状态。如:

    void TestFlags( ios& x ) // 获得x流的三个标志位状态  
    {  
    cout << ( x.rdstate( ) & ios::badbit ) << endl;  
    cout << ( x.rdstate( ) & ios::failbit ) << endl;  
    cout << ( x.rdstate( ) & ios::eofbit ) << endl;  
    cout << endl;  
    }  

    2、bool ios::fail()const;
    1 or true if rdstate & failbit is nonzero, otherwise 0 or false. (引用msdn)
    其中rdstate即通过rdstate()取得的标识变量的值,与failbit相与,即取得failbit标志位的值,如果结果非零则放回true,否则返回false。即该函数返回failbit的状态,将标志位状态通过bool值返回。

    3、bool ios::bad() const;
    1 or true if rdstate & badbit is nonzero; otherwise 0. (引用msdn)
    与fail()相似。

    4、bool ios::good()const;
    1 or true if rdstate == goodbit (no state flags are set), otherwise, 0 orfalse. (引用msdn)
    改函数取goodbit的情况,即三个标志位都0(即没有任何异常情况)时返回true,否则返回false。

    5、voidios::clear(iostate _State=goodbit);
    该函数用来重置标识变量,_State是用来重置的值,默认为goodbit,即默认时将所有标志位清零。用户也可以传进参数,如:clear(failbit),这样就将标识变量置为failbit(即:001)。
    我们一般是用它的默认值,当cin出现异常,我们用该函数将所有标志位重置。如果cin出现异常,没有重置标志的话没法执行下一次的cin操作。如上一节的程序2的测试二为什么第二次输入操作没有执行?程序8中 cin>>ch 为什么没有执行?都是这个原因!!!
    所以经常在程序中使用 cin.clear(), 为了重置错误标志!

    6、另外还有一个函数 void ios::setstate(iostate_State);
    这个函数也是用来设置标识变量的,但与clear()不同。clear()是将所有标志清零,在置以参数新的标志。而该函数不清零其他的标志,而只是将参数对应的标志位置位。这个函数不是经常使用,这里不再赘述。

    在搞清楚了这几个函数后,对cin输入操作的错误处理就有了比较深的了解了。下面我们回过头来看看上一节程序8的测试,因为第一次用getline()读取字符串超长,所以导致出现异常,大家可以查看一下标志位来验证一下!所以会导致后面的 cin>>ch 语句没有执行。那我们利用前面学习的clear()函数来强制重置错误标志,看看会出现什么情况呢?

    #include<iostream>  
    using namespace std;  
    int main ()  
    {  
    char ch, str[20];  
    cin.getline(str, 5);  
    cout<<"flag1:"<<cin.good()<<endl;   // 查看goodbit状态,即是否有异常  
    cin.clear();                        // 清除错误标志  
    cout<<"flag1:"<<cin.good()<<endl;   // 清除标志后再查看异常状态  
    cin>>ch;   
    cout<<"str:"<<str<<endl;  
    cout<<"ch :"<<ch<<endl;  
    return 0;  
    }  
    


    测试输入:
    12345[Enter]
    输出:
    flag1:0 // good()返回false说明有异常
    flag2:1 // good()返回true说明,clear()已经清除了错误标志
    str:1234
    ch :5
    【分析】程序执行结束还是只执行了一次读操作,cin>>ch还是没有从键盘读取数据,但是与程序8中不同,这里打印了ch的值为'5',而且在cin>>ch之前已经清楚了错误标志,也就是cin>>ch的读操作实际上执行了。这就是前面讲的cin读取数据的原理:它是直接从输入缓冲区中取数据的。此例中,第一次输入"12345",而getline(str, 5)根据参数'5'只取缓冲区中的前4个字符,所以str取的是"1234",而字符'5'仍在缓冲区中,所以cin>>ch直接从缓冲区中取得数据,没有从键盘读取数据!
    也就是当前一次读取数据出错后,如果缓冲区没有清空的话,重置错误标志还不够!要是能将缓冲区的残留数据清空了就好了哦!下面我们再来看一个很重要的函数!

    7、basic_istream&ignore(streamsize _Count = 1, int_type _Delim = traits_type::eof());
    function: Causes a number of elements to be skipped from the current readposition.
    Parameters:
    _Count, The number of elements to skip from the current read position.
    _Delim, The element that, if encountered before count, causes ignore to returnand allowing all elements after _Delim to be read. (引用msdn)

    这个函数用来丢弃输入缓冲区中的字符,第一参数定义一个数,第二个参数定义一个字符变量。下面解释一下函数是怎样执行的:函数不停的从缓冲区中取一个字符,并判断是不是_Delim,如果不是则丢弃并进行计数,当计数达到_Count退出,如果是则丢弃字符退出。例:cin.ignore(5, 'a'); 函数将不断从缓冲区中取一个字符丢弃,直到丢弃的字符数达到5或者读取的字符为'a'。下面我们看个程序例子:

    #include <iostream>  
    using namespace std;
    
    int main()
    {
    	char ch;
    	cin.ignore(5, 'a');
    	cin.get(ch);
    	cout << (int)ch << endl;
    	return 0;
    }

    1.当输入:123456(enter)时,VS和g++都输出54(字符'6'的ASCII码)。如下所示:

    2.当输入:b(enter)b(enter) b(enter) 时,VS和g++都输出10(即最后一个enter的ASCII码)。说明cin.ignore()会读取enter,如下所示:

    3.但当输入:1234(enter)ab(enter)时,VS输出97('a'),g++输出98('b')。

    也就是VS中cin.ignore()将第一个enter读取了,但g++中cin.ignore()未读取第一个enter,而是读取了第一个enter之后的'a'。

    丢弃一个字符:
    我们看看这个函数的默认值,第一个参数默认为1,第二个参数默认为EOF。所以cin.ignore()就是丢弃缓冲区中的第一个字符,这在程序中也是比较常用的!

    #include <iostream>  
    using namespace std;  
    int main()  
    {  
    char c1, c2;  
    cin.get(c1);  
            cin.ignore(); // 用该函数的默认情况,丢弃一个字符,即上次输入结束的回车符  
    cin.get(c2);  
    cout<<c1<<" "<<c2<<endl;   // 打印两个字符  
    cout<<(int)c1<<" "<<(int)c2<<endl; // 打印这两个字符的ASCII值  
    return 0;   
    }  

    测试一输入:
    a[Enter]
    b[Enter]
    输出:
    a
    b
    97 98
    【分析】这样程序就正常了!

    清空整个缓冲区:
    其实该函数最常用的方式是这样的,将第一个参数设的非常大,将第二个参数设为'\n',这样就可以缓冲区中回车符中的所有残留数据,因为一般情况下前面输入残留的数据是没有用的,所以在进行新一次输入操作前将缓冲区中所有数据清空是比较合理。
    如:cin.ignore(1024, '\n'); 
    或者:cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 

     

    参考网址:

    1. https://blog.csdn.net/livecoldsun/article/details/25489429

    2.https://blog.csdn.net/xuexiacm/article/details/8101859#commentsedit

    展开全文
  • C++中cin的详细用法

    万次阅读 多人点赞 2017-08-16 23:33:02
    1.cin简介cin是C++编程语言中的标准输入流对象,即istream类的对象。cin主要用于从标准输入读取数据,这里的标准输入,指的是终端的键盘。此外,cout是流的对象,即ostream类的对象,cerr是标准错误输出流的对象,也...

    代码编译运行环境:VS2012+Win32+Debug。


    1.cin简介

    cin是C++编程语言中的标准输入流对象,即istream类的对象。cin主要用于从标准输入读取数据,这里的标准输入,指的是终端的键盘。此外,cout是流的对象,即ostream类的对象,cerr是标准错误输出流的对象,也是ostream 类的对象。这里的标准输出指的是终端键盘,标准错误输出指的是终端的屏幕。

    在理解cin功能时,不得不提标准输入缓冲区。当我们从键盘输入字符串的时候需要敲一下回车键才能够将这个字符串送入到缓冲区中,那么敲入的这个回车键(\r)会被转换为一个换行符\n,这个换行符\n也会被存储在cin的缓冲区中并且被当成一个字符来计算!比如我们在键盘上敲下了123456这个字符串,然后敲一下回车键(\r)将这个字符串送入了缓冲区中,那么此时缓冲区中的字节个数是7 ,而不是6。

    cin读取数据也是从缓冲区中获取数据,缓冲区为空时,cin的成员函数会阻塞等待数据的到来,一旦缓冲区中有数据,就触发cin的成员函数去读取数据。


    2. cin的常用读取方法

    使用cin从标准输入读取数据时,通常用到的方法有cin>>,cin.get,cin.getline。

    2.1cin>>的用法

    cin可以连续从键盘读取想要的数据,以空格、tab或换行作为分隔符。实例程序如下。

    #include <iostream>
    using namespace std;
    
    int main()
    {
        char a;
        int b;
        float c;
        string 
        cin>>a>>b>>c;
        cout<<a<<" "<<b<<" "<<c<<" "<<endl;
    
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    在屏幕中一次输入:a[回车]11[回车]5.56[回车],程序将输出如下结果:
    这里写图片描述

    注意:
    (1)cin>>等价于cin.operator>>(),即调用成员函数operator>>()进行读取数据。
    (2)当cin>>从缓冲区中读取数据时,若缓冲区中第一个字符是空格、tab或换行这些分隔符时,cin>>会将其忽略并清除,继续读取下一个字符,若缓冲区为空,则继续等待。但是如果读取成功,字符后面的分隔符是残留在缓冲区的,cin>>不做处理。
    (3)不想略过空白字符,那就使用 noskipws 流控制。比如cin>>noskipws>>input;

    验证程序见如下:

    #include <string> 
    #include <iostream>
    using namespace std;
    
    int main()
    {
        char a;
        int b;
        float c;
        string str;
        cin>>a>>b>>c>>str;
        cout<<a<<" "<<b<<" "<<c<<" "<<str<<endl;
    
        string test;
        getline(cin,test);//不阻塞
        cout<<"test:"<<test<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    从键盘输入:[回车][回车][回车]a[回车]5[回车]2.33[回车]hello[回车],输出结果是:
    这里写图片描述

    从结果可以看出,cin>>对缓冲区中的第一个换行符视而不见,采取的措施是忽略清除,继续阻塞等待缓冲区有效数据的到来。但是,getline()读取数据时,并非像cin>>那样忽略第一个换行符,getline()发现cin的缓冲区中有一个残留的换行符,不阻塞请求键盘输入,直接读取,送入目标字符串后,再将换行符替换为空字符’\0’,因此程序中的test为空串。

    2.2 cin.get的用法

    该函数有有多种重载形式,分为四种格式:无参,一参数,二参数,三个参数。常用的的函数原型如下:

    int cin.get();
    istream& cin.get(char& var);
    istream& get ( char* s, streamsize n );
    istream& get ( char* s,  streamsize  n, char delim )。
    • 1
    • 2
    • 3
    • 4
    • 1
    • 2
    • 3
    • 4

    其中streamsize 在VC++中被定义为long long型。另外,还有两个重载形式不怎么使用,就不详述了,函数原型如下:

    istream& get ( streambuf& sb);
    istream& get ( streambuf& sb, char delim );
    • 1
    • 2
    • 1
    • 2

    2.2.1 cin.get读取一个字符

    读取一个字符,可以使用cin.get或者cin.get(var),示例代码如下:

    #include <iostream>
    using namespace std;
    
    int main()
    {
        char a;
        char b;
        a=cin.get();
        cin.get(b);
        cout<<a<<b<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输入:e[回车],输出:
    这里写图片描述
    注意:
    (1)从结果可以看出,cin.get()从输入缓冲区读取单个字符时不忽略分隔符,直接将其读取,就出现了如上情况,将换行符读入变量b,输出时打印两次。

    (2)cin.get()的返回值是int类型,成功:读取字符的ASCII码值,遇到文件结束符时,返回EOF,即-1,Windows下标准输入输入文件结束符为Ctrl+z,Linux为Ctrl+d。cin.get(char var)如果成功返回的是cin对象,因此可以支持链式操作,如cin.get(b).get(c)。

    2.2.2 cin.get读取一行

    读取一行可以使用istream& get ( char* s, streamsize n )或者istream& get ( char* s, size_t n, streamsize delim )。二者的区别是前者默认以换行符结束,后者可指定结束符。n表示目标空间的大小。示例代码如下:

    #include <iostream>
    using namespace std;
    
    int main()
    {
        char a;
        char array[20]={NULL}; 
        cin.get(array,20);
        cin.get(a);
        cout<<array<<" "<<(int)a<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输入:123456789[回车],输出:
    这里写图片描述

    注意:
    (1)从结果可以看出,cin.get(array,20);读取一行时,遇到换行符时结束读取,但是不对换行符进行处理,换行符仍然残留在输入缓冲区。第二次由cin.get()将换行符读入变量b,打印输入换行符的ASCII码值为10。这也是cin.get()读取一行与使用getline读取一行的区别所在。getline读取一行字符时,默认遇到’\n’时终止,并且将’\n’直接从输入缓冲区中删除掉,不会影响下面的输入处理。

    (2)cin.get(str,size);读取一行时,只能将字符串读入C风格的字符串中,即char*,但是C++的getline函数可以将字符串读入C++风格的字符串中,即string类型。鉴于getline较cin.get()的这两种优点,建议使用getline进行行的读取。关于getline的用法,下文将进行详述。

    2.3 cin.getline读取一行

    函数作用:从标准输入设备键盘读取一串字符串,并以指定的结束符结束。
    函数原型有两个:

    istream& getline(char* s, streamsize count); //默认以换行符结束
    istream& getline(char* s, streamsize count, char delim);
    • 1
    • 2
    • 1
    • 2

    使用示例:

    #include <iostream>
    using namespace std;
    int main()
    {
        char array[20]={NULL};
        cin.getline(array,20); //或者指定结束符,使用下面一行
        //cin.getline(array,20,'\n');
        cout<<array<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    注意,cin.getline与cin.get的区别是,cin.getline不会将结束符或者换行符残留在输入缓冲区中。


    3. cin的条件状态

    使用cin读取键盘输入时,难免发生错误,一旦出错,cin将设置条件状态(condition state)。条件状态标识符号为:
    goodbit:无错误
    eofbit:已到达文件尾
    failbit:非致命的输入/输出错误,可挽回
    badbit:致命的输入/输出错误,无法挽回
    若在输入输出类里.需要加iOS::标识符号。与这些条件状态对应的就是设置、读取和判断条件状态的流对象的成员函数。他们主要有:
    s.eof():若流s的eofbit置位,则返回true;
    s.fail():若流s的failbit置位,则返回true;
    s.bad():若流s的badbit置位,则返回true;
    s.good():若流s的goodbit置位,则返回true;
    s.clear(flags):清空状态标志位,并将给定的标志位flags置为1,返回void。
    s.setstate(flags):根据给定的flags条件状态标志位,将流s中对应的条件状态位置为1,返回void。
    s.rdstate():返回流s的当前条件状态,返回值类型为strm::iostate。strm::iostate 机器相关的整形名,由各个iostream类定义,用于定义条件状态。

    了解以上关于输入流的条件状态与相关操作函数,下面看一个因输入缓冲区未读取完造成的条件状态位failbit被置位,再通过clear()复位的例子。

    #include <iostream>
    using namespace std;
    
    int main()
    {
    char ch, str[20]; 
        cin.getline(str, 5);
        cout<<"flag1:"<<cin.good()<<endl;    // 查看goodbit状态,即是否有异常
        cin.clear();                         // 清除错误标志
        cout<<"flag1:"<<cin.good()<<endl;    // 清除标志后再查看异常状态
        cin>>ch; 
        cout<<"str:"<<str<<endl;
        cout<<"ch :"<<ch<<endl;
    
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输入:12345[回车],输出结果为:
    这里写图片描述

    可以看出,因输入缓冲区未读取完造成输入异常,通过clear()可以清除输入流对象cin的异常状态。,不影响后面的cin>>ch从输入缓冲区读取数据。因为cin.getline读取之后,输入缓冲区中残留的字符串是:5[换行],所以cin>>ch将5读取并存入ch,打印输入并输出5。

    如果将clear()注释,cin>>ch;将读取失败,ch为空。
    cin.clear()等同于cin.clear(ios::goodbit);因为cin.clear()的默认参数是ios::goodbit,所以不需显示传递,故而你最常看到的就是:
    cin.clear()。


    4. cin清空输入缓冲区

    从上文中可以看出,上一次的输入操作很有可能是输入缓冲区中残留数据,影响下一次的输入。那么如何解决这个问题呢?自然而然,我们想到了在进行输入时,对输入缓冲区进行清空和状态条件的复位。条件状态的复位使用clear(),清空输入缓冲区应该使用:
    函数原型:istream &ignore( streamsize num=1, int delim=EOF );
    函数作用:跳过输入流中n个字符,或在遇到指定的终止字符时提前结束(此时跳过包括终止字符在内的若干字符)。
    使用示例如下:

    #include <iostream>
    using namespace std;
    
    int main()
    {
        char str1[20]={NULL},str2[20]={NULL};
        cin.getline(str1,5);
        cin.clear();  // 清除错误标志   
        cin.ignore(numeric_limits<std::streamsize>::max(),'\n'); //清除缓冲区的当前行
        cin.getline(str2,20);
        cout<<"str1:"<<str1<<endl;
        cout<<"str2:"<<str2<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    程序输入:12345[回车]success[回车],程序输出:
    这里写图片描述

    注意:
    (1)程序中使用cin.ignore清空了输入缓冲区的当前行,使上次的输入残留下的数据没有影响到下一次的输入,这就是ignore()函数的主要作用。其中,numeric_limits::max()不过是头文件定义的流使用的最大值,你也可以用一个足够大的整数代替它。
    如果想清空输入缓冲区,去掉换行符,使用:
    cin.ignore(numeric_limits< std::streamsize>::max()); 清除cin里所有内容。

    (2)cin.ignore();当输入缓冲区没有数据时,也会阻塞等待数据的到来。

    (3)有个疑问,网上很多资料说调用cin.sync()即可清空输入缓冲区,本人测试了一下,VC++可以,但是在linux下使用GNU C++却不行,无奈之下,linux下就选择了cin.ignore()。


    5.其它从标准输入读取一行字符串的方法

    5.1 getline读取一行

    C++中定义了一个在std名字空间的全局函数getline,因为这个getline函数的参数使用了string字符串,所以声明在了< string>头文件中了。

    getline利用cin可以从标准输入设备键盘读取一行,当遇到如下三种情况会结束读操作:1)到文件结束,2)遇到函数的定界符,3)输入达到最大限度。

    函数原型有两个重载形式:

    istream& getline ( istream& is, string& str);//默认以换行符结束
    istream& getline ( istream& is, string& str, char delim);
    • 1
    • 2
    • 1
    • 2

    使用示例:

    #include <string> 
    #include <iostream>
    using namespace std;
    
    int main()
    {
        string str;
        getline(cin,str);
        cout<<str<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    输入:hello world[回车],输出:
    这里写图片描述

    注意,getline遇到结束符时,会将结束符一并读入指定的string中,再将结束符替换为空字符。因此,进行从键盘读取一行字符时,建议使用getline,较为安全。但是,最好还是要进行标准输入的安全检查,提高程序容错能力。

    cin.getline()类似,但是cin.getline()属于istream流,而getline()属于string流,是不一样的两个函数。

    5.2 gets读取一行

    gets是C中的库函数,在< stdio.h>申明,从标准输入设备读字符串,可以无限读取,不会判断上限,以回车结束或者EOF时停止读取,所以程序员应该确保buffer的空间足够大,以便在执行读操作时不发生溢出。
    函数原型:char *gets( char *buffer );
    使用示例:

    #include <iostream>
    using namespace std;
    int main()
    {
        char array[20]={NULL};
        gets(array);
        cout<<array<<endl;
        system("pause");
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    输入:I am lvlv[回车],输出:
    这里写图片描述

    由于该函数是C的库函数,所以不建议使用,既然是C++程序,就尽量使用C++的库函数吧。


    参考文献

    [1]C++ primer
    [2]百度百科.gets
    [3] http://blog.csdn.net/lanbing510/article/details/5893349#comments
    [4] http://zhidao.baidu.com/link?url=A-4ceyf_uDhBGeqx49dZWWyydS7Y41yZdnAd5GaApsT_YnK-vK5AwvjYfy1psIaKL8nqUN5zy-Z-Be_z55D51K
    [5] https://social.microsoft.com/Forums/zh-CN/c8ae82d8-18ed-42f1-aabf-e3c1de4f4d9f

    展开全文
  • 流对象cin cin>>i; //一次从输入流对象cin提取一个整数 cin.ignore(n);//忽略前面的n个字符 cin.getline(a,m,‘n’);//接收a字符串的m个字符,遇到字符n停止 #include<iostream> using namespace std; ...
  • cin、gets、cin.getline、cin.get的比较 cin.sync()清空缓存区 cin 结束标志:空格、table 可接受数据 结束标志/输入分割 提交标志 可空否 cin 空格、table、回车 回车 不可空 gets char[],空格、table ...
  • C++输入cin,cin.get(),cin.getline()详细比较及例子

    万次阅读 多人点赞 2016-01-25 13:13:39
    本文主要介绍C++输入的cin,cin.get(),cin.getline()的基本用法,介绍他们之间的区别和例子。最后给出一种以任意字符做分隔符的的输入方法。
  • cin,cinget,cingetline,etc

    2016-02-23 21:19:23
    1、cin2、cin.get()3、cin.getline()4、getline()​5、gets()6、getchar()附:cin.ignore(); cin.get()//跳过一个字符,例如不想要的回车,空格等字符1、cin>>用法1:最基本,也是最常用的用法,输入一个数字:#include...
  • 文章目录1 使用cin 获取字符串2 使用 cin.getline() 获取字符串3 使用 cin.get() 获取字符串4 总结 注:转载请标明原文出处链接:https://xiongyiming.blog.csdn.net/article/details/101074733 1 使用cin 获取字符...
  • 一、cin.clear()、cin.sync()  cin.clear()是用来更改cin的状态标示符的。  cin.sync()是用来清除缓存区的数据流的。 如果标示符没有改变那么即使清除了数据流也无法输入。所以两个要联合起来使用。...
  • cin
  • 1、cin.clear():清除cin流的错误状态,将错误标识改为默认0 2、cin.sync():清除缓冲区的数据 3、cin.ignore():用来清除以回车结束的输入缓冲区的内容
  • cin 使用

    2018-12-01 19:27:44
    cin 是istream类的一个对象, 抽取运算符(&gt;&gt;)被设计成使得cin&gt;&gt;factor也是一个istream 对象。 整个while循环的测试表达式的最终结果为cin , cin被用于测试表达式中时,将根据输入是否...
  • cin 在输入字符的格式与对象不匹配的时候,将输入流对象 cin 挂起,即 cin.fail() 返回 FALSE。 注意:未匹配的输入字符将缓存 cin.clear 流标志复位 可以将cin的状态重置,即将其置为true,cin.fail() 返回 TRUE。 ...
  • cin cin.get cin.getline

    2011-07-22 09:49:13
    cincin.get()的结束符只有enter,但会把enter放入队列等待cin.getline()的结束符也只有enter,但不会把enter放入队列如果用cin>>…做过输入,在使用cin.getline之前,需要处理一下。处理的方法很多,你可以在cin>>…...
  • cin相关

    2018-07-13 09:59:07
    cin包含在iostream头文件中,它是istream类的一个对象。 cin使用空白(空格、制表符、换行符)来确定字符串的结束位置,这意味着cin在获取字符数组输入时只读取一个单词。   其类成员函数getline()和get(): 两...
  • 由简到难,深入理解cin

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,437
精华内容 31,774
关键字:

cin