std::cin.getline( ) vs. std::cin
Solution 1
In case with char*, std::cin.getline
getting line, instead of std::cin
getting first word.
Solution 2
Let's take std::cin.getline()
apart. First, there's std::
. This is the namespace in which the standard library lives. It has hundreds of types, functions and objects.
std::cin
is such an object. It's the standard character input object, defined in <iostream>
. It has some methods of its own, but you can also use it with many free functions. Most of these methods and functions are ways to get one or more characters from the standard input.
Finally, .getline()
is one such method of std::cin
(and other similar objects). You tell it how many characters it should get from the object on its left side (std::cin
here), and where to put those characters. The precise number of characters can vary: .getline()
will stop in three cases:
1. The end of a line is reached
2. There are no characters left in the input (doesn't happen normally on std::cin
as you can keep typing)
3. The maximum number of characters is read.
There are other methods and functions that can be used with the std::cin
object, e.g.
std::string s;
int i;
std::cin >> s; // Read a single word from std::cin
std::cin >> i; // Read a single number from std::cin
std::getline(std::cin, s); // Read an entire line (up to \n) from std::cin
std::cin.ignore(100); // Ignore the next 100 characters of std::cin
Solution 3
Did you read any documentation (e.g. http://www.cplusplus.com/reference/string/getline/)?
Basically, std::cin
(or more generally, any std::istream
) is used directly in order to obtain formatted input, e.g. int x; std::cin >> x;
. std::cin.getline()
is used simply to fill a raw char *
buffer.
Solution 4
(Very simplefied)My answer is, that std :: cin.getline()
can contain spaces, while std :: cin >>
can not.
Solution 5
As already others have answered (even better) roughly speaking, use getline()
to read an entire line (i.e., a string terminating with \n
) and cin>>var
to read a number compatible with the type of var
(integer, float, double etc.) or a single word.
In this answer I want to emphasize a problem that arises when mixing the two methods. When you do:
int a;
string s;
cin>>a;
getline(cin, s)
cin
leaves an end of line, \n
, character which is then read by getline();
. It is possible to overcome this problem by using cin.ignore()
.
int a;
string s;
cin>>a;
cin.ignore();
getline(cin, s)
Simplicity
Updated on July 09, 2022Comments
-
Simplicity almost 2 years
When should
std::cin.getline()
be used? What does it differ fromstd::cin
? -
etarion over 13 yearsthe member getline doesn't get you a
std::string
, it's used for filling achar*
buffer. The getline that gets you astd::string
is the free functionstd::getline
. -
Simplicity over 13 years@Oli. Yes, I saw the documentation for a bit but didn't get the idea. Now, I think it is more clear. Thanks.
-
CB Bailey over 13 yearsI don't understand this answer.
std::cin
doesn't get anything; it's just an object. You have to do something with it (e.g. call a member function likeget
) before it does anything. -
alvelcom over 13 years
char s1[256], s2[256]; std::cin >> s1; cin.getline(s2, 256);
-
eq- over 13 years
std::cin >> s1
is a call to a global functionistream& operator>> (istream&, char*)
-
hochan over 3 yearsIt seems to be a good for a simple example. Thank you.
-
Arjuna Deva about 3 yearsThis answer needs to be edited. The wording and explanation are confusing
-
Andreas Wenzel almost 3 years
cin.ignore()
will only discard a single character, whereascin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
will discard the rest of the line, including the newline character. It doesn't seem meaningful to usecin.ignore()
in this case, becausecin>>a
will only read a single word. Therefore, you cannot assume that the next character will be the newline character.