Construtor sobrecarregado em C++

Este artigo explicará como implementar construtores sobrecarregados em C++.

Noções básicas de construtores e sobrecarga de construtor em C++

Construtor é uma função de membro especial na classe C++ com a tarefa de inicializar os objetos da classe. Os construtores não têm nomes especiais e não podem ser chamados diretamente, mas cada vez que uma determinada classe é criada, um construtor correspondente geralmente é chamado. Embora, declaremos construtores com o mesmo nome da própria classe. Como o C++ fornece uma maneira de definir várias funções com o mesmo nome em um determinado escopo, também podemos definir vários construtores para uma única classe.

Observe que as regras de sobrecarga de função se aplicam de forma semelhante aos construtores sobrecarregados, pois eles precisam diferir no número de parâmetros ou tipos que aceitam. C++ designa diferentes tipos de construtores, que geralmente têm casos de uso específicos, mas não vamos nos aprofundar nesses detalhes neste artigo devido ao seu amplo escopo.

No código de exemplo a seguir, a classe Student é definida, incluindo dois membros de dados private do tipo string. Esses membros devem ser inicializados ao criar uma nova instância da classe Student, mas vamos assumir que apenas o membro name é obrigatório. Conseqüentemente, precisamos ter métodos diferentes para construir o objeto desta classe, um dos quais inicializa apenas o membro name.

Assim, definimos o primeiro construtor que pega apenas um parâmetro string e imprime a mensagem correspondente no console. A última etapa é usada apenas para identificar facilmente o comportamento dos construtores. Além disso, também definimos um segundo construtor que aceita dois parâmetros string e inicializa ambos os membros de dados - name e 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;
}

Produção:

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

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

Observe que quando criamos o objeto s1 no programa main, o segundo construtor é chamado, pois fornecemos dois argumentos, e quando s2 é inicializado, o primeiro construtor é chamado. Nesse caso, tínhamos dois construtores com um número diferente de parâmetros, mas, em geral, podemos definir dois construtores com o mesmo número de parâmetros que diferem nos tipos que aceitam.