精华内容
下载资源
问答
  • (C++)cin.getline()和cin.get()的区别
    2021-12-20 16:10:10

    cin.get()

    cin.get(String,ArSize);

    #include<iostream>
    int main()
    {
    using namespace std;
    const int ArSize = 5;
    char A[ArSize];
    char B[ArSize];
    
    cout << "Enter A:\n";
    cin.get(A,ArSize); 
    cout << "Enter B:\n";
    cin.get(B,ArSize);
    cout << A << "\n";
    cout <<  B << "\n";
    return 0;
    }
    

    输入A:
    abcdefg
    输出:
    Enter A:
    abcdefg
    Enter B:
    abcd
    efg


    输入A:
    abc
    输出:
    Enter A:
    abc
    Enter B:
    abc


    在输入A为abcdefg时,由于数组长度只有5,除去末尾需要填充\n,只能读取4个字符,于是 cin.get(A,ArSize); 取走了abcd,剩下的efg\n被cin.get(B,ArSize);读取,也因此,还没等我输入B的值,cin.get(B,ArSize);就已经取着efg\n跑了
    ————
    而在输入A为abc时,同样没等到输入B的值,就直接输出结果了,从输出结果可以看出B的值为\n,那这是因为我输入的是abc\n ,cin.get(A,ArSize);在取走abc后,把\n滞留下来了,导致cin.get(B,ArSize);读取到了\n,于是…cin.get(B,ArSize);啥也没带就直接跑了。

    cin.get(String,ArSize).get();

    .get()会读取掉一个字符,这就解决了上述cin.get(B,ArSize);啥也没带就直接跑的问题

    #include<iostream>
    int main()
    {
    using namespace std;
    const int ArSize = 5;
    char A[ArSize];
    char B[ArSize];
    
    cout << "Enter A:\n";
    cin.get(A,ArSize).get();
    cout << "Enter B:\n";
    cin.get(B,ArSize);
    cout << A << "\n";
    cout <<  B << ".\n";
    return 0;
    }
    

    输入A:
    abc
    输入B:
    efg
    Enter A:
    abc
    Enter B:
    efg
    abc
    efg


    输入A后,第一个cin.get(A,ArSize).get();读取,然后紧接着.get()会把\n读取掉。程序执行到cin.get(B,ArSize);我继续输入efg,程序得以按照预期正常执行!

    cin.getline()

    #include<iostream>
    int main()
    {
    using namespace std;
    const int ArSize = 5;
    char A[ArSize];
    char B[ArSize];
    
    cout << "Enter A:\n";
    cin.getline(A,ArSize);
    cout << "Enter B:\n";
    cin.getline(B,ArSize);
    cout << A << "\n";
    cout <<  B << "\n";
    return 0;
    }
    

    输入:
    abcdefg
    输出:
    Enter A:
    abcdefg
    Enter B:
    abcd


    输入A:
    abc
    输入B:
    efg
    Enter A:
    abc
    Enter B:
    efg
    abc
    efg


    可以看到在输入abcdefg时,相比cin.get(A,ArSize); efg没掉了

    简单点理解就是:
    cin.get(); //读取到数值装不下了,就自己加个\n结束
    cin.getline(); //读取到\n,然后看数组能装多少就装多少

    所以由于cin.getline(); 过于浪费,我们更多的是使用cin.get();


    当getline( )读取空行时,下一条输入语句将在前一条getline( )结束读取的位置开始读取;但当get( )(不是getline( ))读取空行后将设置失效位(failbit)。这意味着接下来的输入将被阻断,但可以用cin.clear()命令来恢复输入


    输入字符串比分配的空间长:如果输入行包含的字符数比指定的多,则getline( )和get( )将把余下的字符留在输入队列中,而getline( )还会设置失效位,并关闭后面的输入


    cin >> string_1;

    cin.getline(string_1,20)

    cin.get(string_1,20)

    cin.get(name,ArSize).get();<=>cin.get(name,ArSize);cin.get();

    (cin >> string_1).get(); <=> (cin >> string_1).get(ch);

    更多相关内容
  • 以下是对cin.get()和cin.getline()的区别进行了详细的分析介绍,需要的朋友可以过来参考下,希望对大家有所帮助
  • 学C++的时候,这几个输入函数弄的有点迷糊;这里做个小结
  • cin.get()等函数的详细用法总结
  • 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

    展开全文
  • 把ch2=cin.get()改为cin.get(ch2),一样输入a,输出结果却是这样,是什么原理让这两者输出结果不一样,求解答![图片说明](https://img-ask.csdn.net/upload/201910/15/1571097564_676233.png) 还有下图中的赋值给...
  • 1.cin>> 1.1cin>>用法1:最基本,也是最常用的用法,输入一个数字: #include <iostream> using namespace std; main () { int a,b; cin>>a>>b; cout<<a+b<<endl; } ...

    1.cin>>

    1.1cin>>用法1:最基本,也是最常用的用法,输入一个数字:

    #include <iostream> 
    using namespace std; 
    main () 

    int a,b; 
    cin>>a>>b; 
    cout<<a+b<<endl; 
    }

    输入:2[Enter]3[Enter] 
    输出:5

    注意:>> 是会过滤掉不可见字符(如 空格 回车,TAB 等) 

    1.2cin>>用法2:接受一个字符串,遇“空格”、“TAB”、“回车”都结束

    #include <iostream> 
    using namespace std; 
    main () 

    char a[20]; 
    cin>>a; 
    cout<<a<<endl; 
    }

    输入:jkljkljkl 
    输出:jkljkljkl

    输入:jkljkl jkljkl       //遇空格结束 
    输出:jkljkl

    1.3cin总结

    cin在读取时忽略空格换行符等。发送给cin的输入被缓冲,只有在用户按下回车键后,整个字符序列将被发送给程序

    2.cin.get()

    2.1ch = cin.get()与cin.get(ch)与cin.get()

    1.假设 cin 是正被读入字符的 char 变量的名称:cin.get (ch);      ch = cin.get(); 

    2.1.1cin.get(无参数)

    1.cin.get(无参数)主要是用于舍弃输入流中的不需要的字符,或者舍弃回车。(书p81混合输入数字和字符串时用到了)

    2.如果程序正在使用 get 函数简单地暂停屏幕直到按回车键,并且不需要存储字符,则该函数也可以这样用:cin.get();(感觉相当于system("pause");)。(书p218程序清单7.7)

    2.1.2cin.get(ch);与ch = cin.get();

    使用cin.get(ch):

    char ch
    cin.get(ch);
    while (cin.fail() == false)
    {
    	cout << ch;
    	++count;
    	cin.get(ch);
    }

     使用ch = cin.get()

    int ch
    ch = cin.get();
    while (ch != EOF)
    {
    	cout << ch;
    	++count;
    	ch = cin.get( );
    }

                                                            cin.get(ch)与ch= cin.get()

    属性cin.get(ch)ch=cin.get()
    传递输入字符的方式赋给参数ch将函数返回值赋给ch
    用于字符输入时函数的返回值istream对象(执行bool转换后为true)int类型的字符编码
    到达EOF时函数返回值istream对象(执行bool转换后为false)EOF

     另外,与cin.get()相同,cin.get(ch)也可用于舍弃输入流中的不需要的字符,或者舍弃回车。(书p81混合输入数字和字符串时用到了)。

    2.2cin.get(字符数组名,接受字符数目)

    cin.get(字符数组名,接收字符数目)用来接收一行字符串,可以接收空格

    #include <iostream> 
    using namespace std; 
    main () 

    char a[20]; 
    cin.get(a,20); 
    cout<<a<<endl; 
    }

    输入:jkl jkl jkl 
    输出:jkl jkl jkl

    输入:abcdeabcdeabcdeabcdeabcde (输入25个字符) 
    输出:abcdeabcdeabcdeabcd              (接收19个字符+1个'\0')

     3.cin.getline();

    cin.getline()   // 接受一个字符串,可以接收空格并输出

    #include <iostream> 
    using namespace std; 
    main () 

    char m[20]; 
    cin.getline(m,5); 
    cout<<m<<endl; 
    }

    输入:jkljkljkl 
    输出:jklj

    接受5个字符到m中,其中最后一个为'\0',所以只看到4个字符输出;

    如果把5改成20: 
    输入:jkljkljkl 
    输出:jkljkljkl

    输入:jklf fjlsjf fjsdklf 
    输出:jklf fjlsjf fjsdklf

    //延伸: 
    //cin.getline()实际上有三个参数,cin.getline(接受字符串的名称,接受个数,结束字符) 
    //当第三个参数省略时,系统默认为'\0' 
    //如果将例子中cin.getline()改为cin.getline(m,5,'a');当输入jlkjkljkl时输出jklj,输入jkaljkljkl时,输出jk

    当用在多维数组中的时候,也可以用cin.getline(m[i],20)之类的用法:

    #include<iostream> 
    #include<string> 
    using namespace std;

    main () 

    char m[3][20]; 
    for(int i=0;i<3;i++) 

    cout<<"\n请输入第"<<i+1<<"个字符串:"<<endl; 
    cin.getline(m[i],20); 
    }

    cout<<endl; 
    for(int j=0;j<3;j++) 
    cout<<"输出m["<<j<<"]的值:"<<m[j]<<endl;

    }

    请输入第1个字符串: 
    kskr1

    请输入第2个字符串: 
    kskr2

    请输入第3个字符串: 
    kskr3

    输出m[0]的值:kskr1 
    输出m[1]的值:kskr2 
    输出m[2]的值:kskr3

    展开全文
  • cin.get()和cin.getline()、getline()和gets()、getchar()的区别
  • 文章目录cincin.get( )cin.getline() cin 特点:忽略空格,回车符,Tab等不可见的符号;当且仅当回车后数据才会传入; 用法: //输入一个数 int k; cin >> k; // 输入,直到不满足条件 while(cin >> ...

    cin

    • 特点:忽略空格,回车符,Tab等不可见的符号;当且仅当回车后数据才会传入;
    • 用法:
    //输入一个数
    int k;
    cin >> k;
    
    // 输入,直到不满足条件
    while(cin >> k)
    	//某种操作
    	cout << k;
    
    • 如,输入:1 2 3 4[enter]
    • 输出:1234

    cin.get( )

    • 特点:输入一行,遇到enter则结束,且会将enter保留;
    • 用法:
    1. 一个参数,代表输入一个字符输入字符足够后回车
    char ch;
    char ch2;
    cin.get(ch);
    cin.get(ch2);
    cout << int(ch) << ',' << int(ch2);
    

    输入: [enter], 不会结束,输入字符不足(有ch和ch2,至少需要两个字符)
    输入: [enter][enter] 输出: 10,10
    输入:abcd 输出:97,98

    1. 两个参数:
      用法:cin.get(arrayname,size) 把字符输入到arrayname中,长度不超过size
      注释:arrayname必须是char[]类型,即char数组类型,不可以为string类型;size是指输入长度,即允许输入的最大长度。
      具体例子:
      输入串长<size,输入串长>arraylength,会自动扩张arrayname大小,使能保存所有数据
      例1:char a[10];cin,get(a,20);
      输入:123456789012[enter]
      输出a数组:123456789012 可以发现,输入12个字符到a[10]中,系统自动扩充a[10],此时实际数组长为13(‘123456789012’\0’’)。但当计算sizeof(a)时,还是现实为10

    2. 三参数
      用法:cin.get(arrayname,size,s) 把数据输入到arrayname字符数组中,当到达长度size时结束或者遇到字符s时结束
      注释:a必须是字符数组,即char a[]l类型,不可为string类型;size为最大的输入长度;s为控制,遇到s则当前输入结束缓存区里的s将被舍弃
      具体案例:

    #include<iostream>
    using namespace std;
     
    int main()
    {
    	int i;
    	char a[10];
    	cin.get(a,10,'.');
    	cout<<a;
    }
    

    输入:abc.123

    输出:abc 遇到 ’.‘ 输入结束

    4.无参数
    可用于输入一行不知道个数的数字
    案例:

    #include<iostream>
    #include<vector>
    using namespace std;
    int main(){
     int num2;
      vector<int> res2;
      
      int k;
      cin >> k;
      res2.push_back(k);       // 重点!!! 若没有这几行,输入缺少第一个数
      
      while(cin.get() != '\n')
        {
          cin >> num2;
          res2.push_back(num2);
        }
    
      int len2 = res2.size();
      
       for(int i=0;i<len2;++i)
        cout << res2[i] << ' ';
      cout << endl;
    
      return 0;
    }
    

    输入: 1 2 3 4 5[enter]
    输出:1 2 3 4 5

    cin.getline()

    • cin.getline()的用法和cin.get()用法大致相同,没有一参数用法,只有二参数,三参数两类
    • cin.getline(arrayname,size)与cin.get(arrayname,size)的区别
      cin.get(arrayname,size)当遇到[enter]时会结束目前输入,他不会删除缓冲区中的[enter]
      cin.getline(arrayname,size)当遇到[enter]时会结束当前输入,但是删除缓冲区中的[enter]
      案例:
    #include<iostream>
    using namespace std;
     
    int main()
    {
    	char a[10];char b;
            cin.get(a,10);
    	cin.get(b);
    	cout<<a<<endl<<int(b);
    }
    

    输入:12345[enter]

    输出:12345 【换行】 10

    说明:cin.get(a,10)把12345到a中,遇到[enter]结束,但是不把[enter]删除,则把[enter]输入到b中,(enter的ASCALL码为10)

    #include<iostream>
    using namespace std;
     
    int main()
    {
    	char a[10];char b;
            cin.getline(a,10);
    	cin.get(b);
    	cout<<a<<endl<<int(b);
    }
    

    输入:12345[enter]a[enter]

    输出:12345【换行】97

    说明:cin.getline(a,10)吧12345输入到a中,遇到{enter}结束,并把缓冲区中[enter]删除,把接下来的a输入到b中

    • cin.getline(arrayname,size,s)与cin.gei(arrayname,size,s)的区别
      cin.getline(arrayname,size,s)当遇到s时会结束输入,并把s从缓冲区中删除
      cin.get(arrayname,size,s)当遇到s时会结束输入,但不会删除缓冲区中的s

    参考:
    https://blog.csdn.net/a1015553840/article/details/50579396
    https://blog.csdn.net/lc013/article/details/77603310

    展开全文
  • 总结一波cin的详细用法 正文 cin介绍 cin 是 C++ 的标准输入流对象,即 istream 类的对象。cin 主要用于从标准输入读取数据,这里的标准输入,指的是终端的键盘。此外,cout 是输出流对象,即 ostream 类的对象,...
  • cin.get(char &_Ch) cin.get(char &_Ch):将输入的char赋值给ch;当检测到EOF时cin的eof方法返回true,fail方法返回true。 下面是一个使用cin.get(char &_Ch)来逐个读取输入字符的demo,当输入EOF时停止...
  • 的编程练习时,注意到了cin.get(ch)和ch=cin.get()在用法上有一点特别之处. 先说结论: cin.get(ch)和ch=cin.get()在一定情况下可以相互替换. 要特别注意的是优先级. 赋值运算符("=")的优先级小于逻辑运算符("&&...
  • [C++] cin.get(),cin.getline(),cin.clear()使用技巧

    千次阅读 多人点赞 2018-11-08 20:22:14
    cin是用于输入的istream类的... ch、cin.get(ch)、ch = cin.get()、cin.getline()等多种方式,看似简单,但其中的细节却非常重要,理解了这些cin的特点,那么cin在一些特殊场景下的用法也就一目了然了。如将cin用作...
  • 1.cin.get() 用法1: cin.get(字符变量名)可以用来接收字符 #include <iostream> using namespace std; int main() { char ch; ch = cin.get(); cout << ch << endl; return 0; } 输入:...
  • C++之cin.get()用法

    2021-05-25 00:40:11
    /** ************************... * @file cin_get.cpp * @author Zhen Haiyang * @version 1.0 * @date 2021-05-25 00:18:07 * @brief cin.get()使用方法 ****************************************************
  • 原文:... 文章目录1.cin的基本用法2.cin.get()基本用法(1)一参数(2)二参数3.cin.getline()基本用法(1)cin.getline(arrayname,size)与cin.get(arrayname,size)的区别(2)cin.getline(arrayn...
  • 下面先看下C++ cin.getline用法,具体内容如下所示: 使用 C++ 字符数组与使用 string 对象还有另一种不同的方式,就是在处理它们时必须使用不同的函数集。例如,要读取一行输入,必须使用 cin.getline 而不是 ...
  • 文章目录cincin.get()1.cin.get(char)2.cin.get(字符数组名,接收字符数目)getscin.getline()getline() cin 读取单个字符时候,cin将忽略空格和换行符。因此输入中的空格没有被回显,也没有包括在计数内。 发送给cin...
  • c++ 中的 cin.get()函数

    千次阅读 多人点赞 2020-10-01 16:50:50
    #include <iostream> #include <sstream> #include <... ch = cin.get();//从标准输入接受一个字符 while(ch != ' ') //只要这个字符不是' '空格即可 { cout << ch <.
  • 此文章是我在自己写代码时,每次结合使用不同的输入方法时...cin.get 的读取字符规则: 读取字符: 以回车键结束,并且会将回车键作为一个字符读入,读完回车键之后,指针光标移到回车键后面,如果后面还有输入的话
  • cin,cin.get,cin.getline等函数深入分析.doc
  • cin.get(ch)与ch = cin.get()的区别

    千次阅读 2018-12-11 11:01:36
    cin.get(ch)和ch = cin.get()的区别 ch = cin.get() ;//先调用cin.get()函数,然后将该函数的返回值赋给ch,语句的结果为ch的值。 cin.get(ch);//在到达EOF值时,不会赋值给ch,ch只是接收输入字符。 二者的区别...
  • cin.get()的用法

    千次阅读 多人点赞 2021-01-07 15:28:30
    cin.get有三种形式: 1.输入单个字符 char str = cin.get() /cin.get(str) 上述两种形式等级,用于获取一个字符 char ch; ch=cin.get(); //或者cin.get(ch);只能获取一个字符 cout<<ch<<endl; 举例: ...
  • cin输入后换行符留在输入队列中 cin.getline(name,length)输入一行后丢弃换行...cin.get(name,length)输入一行后不丢弃换行符,把他留在输入队列中 但是同时用cin输入时,>>会自动跳过空字符(包括换行符) ...
  • 1、cin.get(str, Size) 读取Size个字符或直到遇到\n时止,并且将\n留在输入缓冲区中,其将被下一个读取输入的操作捕获。 2、cin,get() cin.get( )的一个重载函数:使用不带任何参数的cin.get()可读取缓冲区的下一个...
  • cin.get() 用法1: cin.get(字符...
  • 关于C++中cincin.get(),cin.getline(),getline()笔记 C++处理字符串方式有两种,一种是来自C语言(C-style string);另一种基于string类库的方法。 C风格字符串必须以空字符(null character)结尾,空字符被...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,650
精华内容 45,060
关键字:

cin.get()

友情链接: RSAPublicKeyStructure.rar