Überladen von Funktionen

Überladene Funktionen müssen sich in Anzahl und/oder Typ der Argumente unterscheiden. Das Funktionsergebnis ist kein Unterscheidungsmerkmal.

Folgendes sind keine überladenen Funktionen:

   int max(int i, int k);
   int max(int a, int b);

Das ist eine Redeklaration der gleichen Funktion (erlaubt).

   
   int max(int, int);
   unsigned int max(int, int);

Das ist eine Redeklaration der gleichen Funktion (verboten, da Ergebnistypen verschieden).

    typedef char* string;
    int suche(char*, string);
    int suche(char*, char*);

Typedef führt keinen neuen Typ ein. Das ist also die Redeklaration der gleichen Funktion (erlaubt).  

Zur Identifikation einer überladenen Funktion geht der Compiler wie folgt vor (für einen Parameter):

 

1.

Nimm die Funktion, bei der der Argumenttyp genau paßt:

    double sqrt(double);  // <--- diese
    float sqrt(float);
    cout << sqrt(7.777);

2.

Wenn eine einzige Funktion paßt, nachdem char, unsigned char, short nach int, unsigned short entweder nach int oder nach unsigned int (falls sizeof(short) < sizeof(int)) und float nach double umgewandelt wurde, oder triviale Umwandlungen wie T nach T& oder T nach const T angewendet wurden, nimm diese:

    int inc(int);  // <--- diese
    float inc(float);
    cout << inc('x');

3.

Wenn eine einzige Funktion nach den anderen Standard-Umwandlungen paßt, nimm diese:

    int testptr(char *);
    int testptr(void *);   // <--- diese    
    list *lp;
    cout << testptr(lp);

4.

Wenn eine einzige Funktion nach benutzerdefinierten Umwandlungen paßt, nimm diese:

    class cmplx
    { cmplx(double);
      ...
    };
    double max(cmplx,cmplx); // <--- diese
    cmplx max(char *list);
    cout << max(2,3);

Gibt es mehrere Funktionsargumente, muß eine Funktion gefunden werden, die in einem Argument besser paßt als alle anderen und in den anderen Argumenten mindestens genauso gut.

Hier wird die Sache recht kompliziert