As funções em C++ : sobrecarga e configurações padrão

Novembro 2016


Em C + +, uma mesma função ou método de classe pode ser substituída, e ter o que chamamos de configurações padrão. Esta qualidade também se aplica aos construtores de classe.

A sobrecarga de funções e métodos de classes, inclusive o construtor


Ao sobrecarregar uma função, declaramos duas vezes ou mais, mantendo o mesmo nome e o
mesmo tipo de retorno. Alterar o tipo de retorno corresponderia ao polimorfismo.

Exemplo: Polygone.hpp

#include <iostream>  

using namespace std;  

class Polygone {  

public :   

Polygone();  
Polygone(int númeroCota);  
Polygone(int númeroCota, bool regular);  
Polygone(bool regular);  

void setRegulier()  { cout << "Ótimo Eu sou regular!" << endl;  
                      regular = true; }  
                        
void setPolygone(int nbCote) { seuNúmeroCota = nbCote; }  

void setTamanho(int tamanhoCota1) { cout << "Eu conheço o tamanho da minha primeira cota: ele mede" << tailleCote1 << " cm." << endl;  
                                  seuTamanhoCota1 = tamanhoCota1; }  
                                    
void setTamanho(int tamanhoCota1, int tamanhoCota2)   
{ cout << "Eu conheço o tamanho da minha primeira cota: ela mede "<< tamanhoCota1 << " cm." << endl;  
  cout << "Eu conheço o tamanho da minha segunda cota: elamede  "<< tamanhoCota2 << " cm." << endl;  

  seu tamanhoCota1 = tamanhoCota1;  
  seu tamanhoCota2 = tamanhoCota2; }  
                                                     
void setTamanho(int tamanhoCota1, int tamanhoCota2, int tamanhoCota3)   
{ cout << "Eu conheço o tamanho da minha primeira cota: ela mede " << tamanhoCota1<< " cm." << endl;                                                                  
  cout << "Eu conheço o tamanho da minha segunda cota: ela mede " << tamanhoCota2<< " cm." << endl;  
  cout << "JEu conheço o tamanho da minha terceira cota: ela mede "<< tamanhoCota3<< " cm." << endl;  

 seu tamanhoCota1 = tamanhoCota1;  
 seu tamanhoCota2 = tamanhoCota2;
 seu TamanhoCota3 = TamanhoCota3; }  

private :  

bool regulier;  
int sonNúmeroCota;  
int seuTamanhoCota1;  
int seuTamanhoCota2;  
int seuTamanhoCota3;  

};


Este exemplo ilustra a declaração da classe "Polígono", que utiliza a sobrecarga do construtor e
da função setTamanho();

Vejamos agora o Polygone.cpp :

#include "polygone.hpp"  

using namespace std;  

Polygone::Polygone() {  

cout << endl << "Eu sou um polígono, mais je ne sais pas si je suis regulier, ni combien j'ai de cotes, ni leur taille." << endl;  
}  

Polygone::Polygone(int númeroCota) {  

cout<< endl << "Eu sou um polígono com " << númeroCota <<" cotas mas eu não conheço o seu   tamanho, e eu não sei se eu sou regular." << endl;  
seuNúmeroCota = númeroCota;  
}  

Polygone::Polygone(int númeroCota, bool regulier) {  

cout << endl << "Eu sou um polígono com " << númeroCota <<" cotas mas eu não conheço o seu   tamanho.";  
if(regular == true)  
     cout << "Eu sou regular !" << endl;  
else cout << "Eu não sou regular." << endl;  
seu NúmeroCota = númeroCota;  
regular = true;  
}  


Neste exemplo, vemos a aplicação de métodos sobrecarregados.
Isso acontece exatamente da mesma maneira para as funções não-membros.

Você pode testar esses dois arquivos com o arquivo main.cpp:

#include "polygone.hpp"  
#include <iostream>  

using namespace std;  

int main(int argc, char *argv[])  
{  
    cout << endl << "Polígono simples:";  
    Polygone polígonoSimples;  
      
    cout << endl << "Polígono com três lados:";  
    Polygone polígonoComTrêsLados(3);  
      
    cout << endl << "Polígono com sete lados:";  
    Polygone polígonoComSeteLados Regular(7, true);  
      
    cout << endl << "Polígono simples:";  
    polygoneSimple.setRegular();  
      
    cout << endl << "Polígono com três lados:" << endl;  
    polígonoComTrêsLados.setTamanho(5, 7, 1);  
      
    cout << endl << "Polígono com sete lados:" << endl;  
    polígonoComSeteLadosRegular.setTamanho(1, 90);  
      
    cout << endl << endl;  
    system("PAUSA");  
    return EXIT_SUCCESS;  
}


Você pode ver que o código é satisfatório.

Utilização dos parâmetros padrão


Utilizar as configurações padrão pode ser útil quando você não conhece o valor de
determinados parâmetros, enquanto uma função os atende.

Na declaração, as configurações padrão devem ficar na extrema direita.


Exemplo: redefinição da função setTamanho:

void setTamanho(int tamanhoCota1 = 5, int tamanhoCota2 = 8, int tamanhoCota3 = 4)   
{ cout << "Eu conheço o tamanho da minha primeira cota: ela mede" << tailleCote1 << " cm." << endl;                                                                  
  cout << "Eu conheço o tamanho da minha segunda cota: ela mede" << tailleCote2 << " cm." << endl;  
  cout << "Eu conheço o tamanho da minha terceira cota: ela mede" << tailleCote3 << " cm." << endl;  

 seu tamanhoCota1 = tamanhoCota1;  
 seu tamanhoCota2 = tamanhoCota2;
 seu TamanhoCota3 = TamanhoCota3; }  


Isto é extremamente simples. Agora olhe para o uso com o main.cpp, também
alterado para mais utilidade:
 


#include "polygone.hpp"  

using namespace std;  

int main(int argc, char *argv[])  
{  

    cout << endl << "Polígono simples:";  
    Polygone polígonoSimples;  

    cout << endl << "Polígono com três lados:";  
    Polygone polígonoComTrêsLados(3);  

    cout << endl << "Polígono com sete lados:";  
    Polygone polígonoComSeteLados Regular(7, true);   

    cout << endl << "Polígono simples:";  
    polígonoSimples.setTamanho();  
      
    cout << endl << "Polígono com três lados: " << endl;  
    polígonoComTrêsLados.setTamanho(1, 90);  
      
    cout << endl << "Polígono com sete lados: " << endl;  
    polígonoComTrêsLadosRegular.setTamanho();  
      
    cout << endl << endl;  
    system("PAUSE");  
    return EXIT_SUCCESS;  
}


Você pode testar este código.


Tradução feita por Lucia Maurity y Nouira

Veja também :
Este documento, intitulado « As funções em C++ : sobrecarga e configurações padrão »a partir de CCM (br.ccm.net) está disponibilizado sob a licença Creative Commons. Você pode copiar, modificar cópias desta página, nas condições estipuladas pela licença, como esta nota aparece claramente.