Doubt with data input by the user

Within object-oriented programming, it is common for objects to have a series of methods that allow them to interact with the object. It is the example of cin.getline.

On the other hand, languages ​​like C++ support operator overloading. In some languages ​​like C, each operator fulfills a very specific mission and only for native types (those predefined by the language) and its use cannot be modified under any circumstances. The addition operator serves as an example:

int a = 5, b = 2;
int c = a + b; // correcto

struct test
{
  int valor;
};

struct test a,b;
a.valor = 5;
b.valor = 2;
struct test c = a + b; // ERROR, el compilador no sabe como aplicar este operando a una estructura

As we have said, in C++ it is possible to redefine the behavior of certain operands to adapt them to particular objects of our program. So we could do the following:

struct test
{
  int valor;

  test& operator+(test& otro)
  {
    test toReturn;
    toReturn.valor = valor + otro.valor;
    return toReturn;
  }
};

struct test a, b;
a.valor = 3;
b.valor = 2;
struct c = a + b; // Correcto
std::cout << c.valor << '\n'; // Imprime 5

Along the same lines, other operators that can be overloaded are the insert <<and remove operators >>:

struct test
{
  int valor;

  test& operator+(test& otro)
  {
    test toReturn;
    toReturn.valor = valor + otro.valor;
    return toReturn;
  }

  friend std::ostream&& operator<<(std::ostream& out, test& dato);
  friend std::istream&& operator>>(std::istream& in, test& dato);
};

std::ostream&& operator<<(std::ostream& out, test& dato)
{
  return out << dato.valor;
}

std::istream&& operator>>(std::istream& in, test& dato)
{
  return out >> dato.valor;
}

struct a;
std::cin >> a; // Se recibirá un entero y se almacenará en a.valor;
std::cout << a; // Se imprimirá el valor almacenado en a.valor;

I'm not going to go into detail about the use of friendbecause that would lead me into a number of topics that are beyond the scope of the question.

Of course, overloading operators is something to do only in very special cases to avoid unexpected behavior due to silly language details such as implicit conversions.

As an additional detail, say that the operators can be called just like any other function. So we can do the following:

struct test a, b;
a.valor = 3;
b.valor = 2;
struct c = a.operator+(b); // Correcto
std::cout << c << '\n'; // Imprime 5

Thus, the use of the operator >>is determined by a series of overloads of the operator, while cin.getlineit is just a member function of cin.

Of course, when deciding which option to use, pay close attention to the details of each function. The standard library has few redundant options. This means that two functions can work the same only in appearance.

So, for example, cin.getlineit reads a text string until a newline (or a null character) is encountered, while the operator >>stops when it also encounters a space.

If, for example, on the keyboard you type "Esto es una prueba":

• cin.getlinewill recover"Esto es una prueba"
• cin >> varwill recover"Esto"

This without taking into account the fact that the operator >>allows you to retrieve integers, floating point numbers, ... while it cin.getlineonly allows you to read text strings.

cinit can "read" (convert, actually cast) any data type and store it in a variable, instead cin.getlineit only stores strings (expects char*as parameter).

To show an example of when you would use which:

#include <iostream>
using namespace std;

int main() {
  int numero;
  char cadena[11];

  cout << "Ingrese su edad: ";
  cin >> numero;
  cin.ignore(); // consumir Enter (\n)

  cout << "Ingrese su nombre: ";
  cin.getline(cadena, 10);

  cout << "Su nombre es: " << cadena << " Y su edad: " << numero;

  return 0;
}