Constructor sobrecargado en C++

Este artículo explicará cómo implementar constructores sobrecargados en C++.

Conceptos básicos de constructores y sobrecarga de constructores en C++

Constructor es una función miembro especial en la clase C++ encargada de inicializar los objetos de la clase. Los constructores no tienen nombres especiales y no se pueden llamar directamente, pero cada vez que se crea una clase determinada, generalmente se invoca un constructor correspondiente. Aunque, declaramos constructores con el mismo nombre que la propia clase. Dado que C++ proporciona una forma de definir varias funciones con el mismo nombre en un ámbito determinado, también podemos definir varios constructores para una sola clase.

Tenga en cuenta que las reglas de sobrecarga de funciones se aplican de manera similar a los constructores sobrecargados, ya que deben diferir en el número de parámetros o tipos que aceptan. C++ designa diferentes tipos de constructores, que a menudo tienen casos de uso específicos, pero no profundizaremos en estos detalles en este artículo debido a su alcance masivo.

En el siguiente código de ejemplo, se define la clase Student, que incluye dos miembros de datos private de tipo string. Se supone que estos miembros deben inicializarse al crear una nueva instancia de la clase Student, pero supongamos que solo el miembro name es obligatorio. En consecuencia, necesitamos tener diferentes métodos para construir el objeto de esta clase, uno de los cuales solo inicializa el miembro name.

Por lo tanto, definimos el primer constructor que toma solo un parámetro string e imprime el mensaje correspondiente en la consola. El último paso solo se usa para identificar fácilmente el comportamiento de los constructores. Además, también definimos un segundo constructor que acepta dos parámetros string e inicializa ambos miembros de datos: name y last_name.

#include <iostream>

using std::cout;
using std::endl;
using std::string;

class Student {
 private:
  string name;
  string last_name;

 public:
  explicit Student(string n) : name(std::move(n)) {
    cout << "Constructor 1 is called" << endl;
  };
  Student(string &n, string &ln) : name(n), last_name(ln) {
    cout << "Constructor 2 is called" << endl;
  };

  string getName() { return name; }

  string getLastName() { return last_name; }
};

int main() {
  string n1("James");
  string n2("Kale");

  Student s1(n1, n2);
  cout << s1.getName() << endl;
  cout << s1.getLastName() << endl;
  cout << "------------------" << endl;

  Student s2(n1);
  cout << s2.getName() << endl;
  cout << s2.getLastName() << endl;
  cout << "------------------" << endl;

  return EXIT_SUCCESS;
}

Producción :

Constructor 2 is called
James
Kale
------------------
Constructor 1 is called
James

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

Observe que cuando creamos el objeto s1 en el programa main, se invoca el segundo constructor ya que proporcionamos dos argumentos, y cuando se inicializa s2, se llama al primer constructor. En este caso, teníamos dos constructores con diferente número de parámetros, pero en general, podemos definir dos constructores con el mismo número de parámetros que difieren en los tipos que aceptan.