Tell me if I'm right-

I'm trying to recall all of the versions of std::cin and how they deal with string input. Please correct me if I'm wrong or if I'm missing any (I'm typing all of this from memory).

cin>> reads chars into the variable or array. Terminates upon blank characters and throws away \n characters produced by the enter key. If it's an array, it adds the null character at the end.

cin.get() reads a char from the input stream and returns it. Leaves the \n character in the input buffer.

cin.get(ch) reads a char from the input stream and stores it in ch. Leaves the \n character in the input buffer.

cin.get(chArray, 50) reads up to 50 characters from the input stream and stores them in chArray. Leaves the \n character in the input buffer. Puts the null character where the \n was.

cin.getline(chArray, 50) reads up to 50 characters from the input stream and stores them in chArray. Reads and throws away the newline character. Puts the null character where the \n was.

Please make any corrections necessary. I'm tired of not being able to correctly remember what all these do.

this might help: http://www.cppreference.com/cppio/

Quote:

---

Originally Posted by homeyg

cin>> reads chars into the variable or array. Terminates upon blank characters and throws away \n characters produced by the enter key. If it's an array, it adds the null character at the end.

---

Wrong about throwing away '\n' characters. By default, using cin >> leaves the '\n' character and any other whitespace around that comes after the data it reads in. It skips whitespace that comes before the word it reads.

Quote:

---

Originally Posted by homeyg

cin.get() reads a char from the input stream and returns it. Leaves the \n character in the input buffer.

---

It reads in one character. It leaves the next character in the input buffer. No need to specify '\n', since it behaves the same as any other character (or whitespace). If the current character happens to be '\n', then it will be read, not left in the input buffer.

Quote:

---

Originally Posted by homeyg

cin.get(ch) reads a char from the input stream and stores it in ch. Leaves the \n character in the input buffer.

---

Same as above. If the current character happens to be '\n', then it will be read, not left in the input buffer.

Quote:

---

Originally Posted by homeyg

cin.get(chArray, 50) reads up to 50 characters from the input stream and stores them in chArray. Leaves the \n character in the input buffer. Puts the null character where the \n was.

---

Wrong about the 50 characters. It reads up to 49 characters to leave room for the null character at the end.

Quote:

---

Originally Posted by homeyg

cin.getline(chArray, 50) reads up to 50 characters from the input stream and stores them in chArray. Reads and throws away the newline character. Puts the null character where the \n was.

---

Same as above. It reads up to 49 characters to leave room for the null character at the end.

For all of the above, change the word 'newline' or '\n' to 'delimiter' so that you remember that you can change the delimiter even though the default is '\n'.

That's a good list to compile. I was just reviewing some of those tonight. In a list like that, I would include the

cin>>number;

followed by

cin.getline(text, maxlength)

problem where the program mysteriously skips over cin.getline(), as well as the cin.ignore() fix. You might also want to include the parameters for each function. Several of them take a third parameter which allows you to specify the delimiter, and enables you to skip over the \n and read in multiple lines

I've got a question. I know that on different systems the carriage return character is different:

Windows: \r\n
Mac: \r
Unix: \n

so why doesn't the \r muck things up in C++ programs?

a \n can be related to \r\n, which is (carriage return)(feed). in the olden days, when you typed a line, you would have to send a signal to the printer to bring the print head (the carriage) back to the first column on the page, and then feed one line of the page. then when you started printing, you were on the next line.

as for the "skipping" thing you mentioned: http://www.cprogramming.com/tips/sho...ount=30&page=0

Quote:

---

Originally Posted by major_small

I think it's more like:

Code:

---

Windows: \r\f
Mac: \r
Unix: \f

---

---

Wait a minute now I'm confused. In C++, we talk about \n being entered with the return key, and how it sits in the buffer and because \n is the defaul delimiter for cin.getline(), etc., it can cause problems. Now you're saying \n doesn't even exist?

In any case, my point is if one of the two characters in Windows is the default delimiter for cin.getline(), etc. where does the other character go?

http://www.csee.umbc.edu/help/C++/summary.shtml#Lexical

it's a little hard to explain... '\n' does exist, but in effect, it's the same as sending "\r\f" to the system... the default delimiter in any case for cin.getline is '\n', but yes, if you were using this:

Code:

---

std::cin.getline(line,x,'\r');

---

you would end up with an extra \f in the stream.

edit: you were right, windows uses \r\n, and unix uses \n

edit2: from the mozilla website: http://www.mozilla.org/hacking/porta...#no_cr_in_code

So, what happens when a user on Windows enters the character 'H' into the following program:

Code:

---

#include <iostream>
using namespace std;

int main()
{
    char text[5];
    cin.getline(text, 5);

    cout<<text<<endl;
    return 0;
}

---

Does text look like this:

H\r\0\0\0

but the \r won't display when you use cout<<? Or, does C++ convert \r\n into \n somehow? Or, are all escape sequences in the stream cin discarded?

I/O is required to convert between platform newlines and \n on in- and output.

Quote:

---

I/O is required to convert between platform newlines and \n on in- and output.

---

I need a translation. :(

Both the C and the C++ standards say that in the program, a newline is a single \n character. If the platform uses a different sequence, like \r\n or \r, then the I/O routines (scanf, printf, istream, ostream, ...) are required to convert between them if the source (e.g. a file) is opened in text mode.

Thanks. :)

I was doing some experimenting with cin.get() and cin.getline() and noticed a few things. Here is the code I was using to do the test:

Code:

---

#include <iostream>
using namespace std;
int main()
{
    char ch[10];
    char left[10];
   
    cout<<"Enter characters."<<endl;
   
    cin.getline(ch,10);
    cin.getline(left, 10);
   
    cout<<ch<<endl;
    cout<<left<<endl;
   
   
    system("PAUSE");
    return 0;
}

---

With the code as it is, when I would enter more than 9 characters for the first input, it seems that any characters after 9 are simply thrown away. I'm assuming this is how that function functions. However, there is no chance for any second input. Can someone explain what is happening here?

Are you sure that anything beyond the first 9 characters doesn't end up in left?

No nothing is there when the second array is outputted and there is no chance for input. Run the program for yourself.

Will do, but I first need to grab a compiler. Don't have one on this computer.

Check the return values - cin is put into a fail state after the first getline, so until you clear it all subsequent reads will fail. See what happens when you change the first getline to:

Code:

---

if (!cin.getline(ch, 10))
  cin.clear();

---

Yes, it solves the problem. I never really knew what cin.clear() did before this.

Quote:

---

Originally Posted by Daved

Check the return values - cin is put into a fail state after the first getline, so until you clear it all subsequent reads will fail. See what happens when you change the first getline to:

Code:

---

if (!cin.getline(ch, 10))
  cin.clear();

---

---

Why is cin put in fail safe mode? I can't find any information on getline() that describes that behavior?

MSDN:

Quote:

---

The second function extracts up to _Count - 1 elements and stores them in the array beginning at _Str. It always stores char_type after any extracted elements it stores. In order of testing, extraction stops:

* At end of file.
* After the function extracts an element that compares equal to _Delim, in which case the element is neither put back nor appended to the controlled sequence.
* After the function extracts _Count - 1 elements.

If the function extracts no elements or _Count - 1 elements, it calls setstate(failbit). In any case, it returns *this.

---

http://msdn.microsoft.com/library/de...rFunctions.asp

Thanks.

After playing around a bit with those two successive calls to getline(), this is what I came up with to make the program work in a predictable way:

Code:

---

#include <iostream>
using namespace std;

int main()
{
    char ch[3];
    char left[3];
   
    cout<<"Enter characters."<<endl;
   
    cin.getline(ch,3);
   
    if(cin.fail())  //then there are more characters to read
        cin.clear();
    else  //the buffer is empty
        cout<<"Enter some more characters:\n";
       
    cin.getline(left, 3);
           
    cout<<ch<<endl;
    cout<<left<<endl;
   
    return 0;
}

---