Template Funktion Überladung in C++

Question

Ich habe die folgende Definition.

using namespace std; 

template <typename T> 
void foo(const T &s) { 
    cout << 1; 
} 

template <typename T> 
void foo(const T *s) { 
    cout << 2; 
} 

int main(int argc, const char * argv[]) { 
    char str[] = "ss"; 
    char *s = str; 
    foo(s); 

    return 0; 
} 

Dann gibt es

1 

Von meinem Verständnis haben beide Versionen durch eine konstante Umwandlung zu gehen. Dann ist void foo(const T *s) spezialisierter und sollte aufgerufen werden. Der Compiler hat jedoch void foo(const T& s) gewählt. Was ist die Erklärung?

Answer 1

Einige Leute haben darauf hingewiesen, dass die Parameter der Vorlagen, wie durch den Compiler gewählt

void f(char * const&) 
void f(const char *); 

Hier fällt auf, dass der Compiler einen Zeiger eine konstante Referenz auf char, char*, für die erste Funktion und es ist erwartet . Es kann als eine Überraschung kommen, wenn Sie die für Ihren Fall fand es die erste Vorlage vorzieht, aber für die folgenden zwei, es wird die zweite

template <typename T> 
void foo(const T& s) { 
    cout << 1; 
} 

template <typename T> 
void foo(T &s) { 
    cout << 2; 
} 

Also, natürlich bevorzugen, es wird Blick bei der Const manchmal. Warum war es in deinem Fall nicht? Weil es nur die const für eine Referenz betrachten wird, wenn die andere Funktion auch eine Referenz hat.

In Ihrem Fall char*-const char* ist es eine Zeiger-Konvertierung, aber lvalue-const lvalue, dann ist es nicht wirklich eine Umwandlung. Das Hinzufügen einer Konst mit einer Konst-Referenz wird von der Überladungsauflösung ignoriert, außer wenn beide Funktionen wie im obigen Fall über Referenzparameter verfügen.

Answer 2

Der Grund ist, weil s ein nicht-konstanter Zeiger ist, also int * const & ist eigentlich eine bessere Übereinstimmung als int const *, weil es const nicht zum Zeigertyp hinzufügen muss.

Wenn s const qualifiziert wäre, dann wäre es eine exakte Übereinstimmung für die T const * Version.

Answer 3

beide Versionen müssen eine const-Konvertierung durchlaufen.

Die erste muss nicht konvertiert werden. Für Vorlage Parameter const T& mit Vorlage Argument char *, T wird als char* abgeleitet und dann die Art der Funktion Parameter wird char* const &, so ist es perfekt. Das Funktionsargument wird gebunden, um auf const (T ->const T&, d. H. char* bis char* const&) Bezug zu nehmen, constqualified ist keine Konvertierung.

Für die zweite ein, die Template-Parameter const T* mit Template-Argument char * wird T als char abgeleitet werden und dann wird die Art der Funktionsparameter const char* sein und qualification conversion benötigt wird char*-const char* zu konvertieren.

Von Ihrem Kommentar

Beide Routinen hinzufügen Low-Level-const s.

Der erste fügt const zu s hinzu, aber der zweite ist nicht. Es fügt const hinzu, was s Punkte auf, nicht s selbst ist. Das ist der Unterschied.

Answer 4

Ich habe die const ohne Änderung der Semantik des Codes bewegt, nur damit Sie nicht überrascht, wenn die Position des const „Änderungen“ später.

template <typename T> 
void foo(T const &s) { 
    cout << 1; 
} 

template <typename T> 
void foo(T const *s) { 
    cout << 2; 
} 

char *x = "x"; 
foo(x); 

Überlastungs 1 haben T herzuleiten char* so die Art der zu s wird char * const & (Verweis auf const Zeiger auf nicht-const char) sein. Eine solche Referenz kann ohne Konvertierung an den Argumenttyp (char *; Zeiger an nicht-const char) gebunden werden.

Überlastungs 2 wird T herzuleiten char so die Art der zu s wird char const * (Zeiger char const) sein. Dies führt zu einer Qualifizierungskonvertierung von dem Argumenttyp (char *; Zeiger zu nicht-konstant char) zu dem Parametertyp (char const *; Zeiger zu const char).

Ein illustratives Beispiel des Prinzips in Überlast 1 ist folgende:

int n = 42; 
int const &i = n; 

Binden eines const Verweis auf eine nicht-const Entität keine Umwandlung beteiligt, weil es die Bezugnahme der, dass die Qualifikation fügt Es ist nicht die Qualifikation, die der Entität hinzugefügt wird, um sie dem Referenztyp zuzuordnen.

Answer 5

Der Grund ist, weil, wenn das Argument ein Zeiger ist, müssen Sie .. in einem Zeiger übergeben So:

// Example program 
#include <iostream> 
#include <string> 

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

void foo(int *a) 
{ 
    cout << *a << endl; 
} 

int main() 
{ 
    int a = 5; 
    foo(&a); 
} 

Aber wenn Ihr Argument ein refrence ist, können Sie einfach den Parameter übergeben, wie es ist dies wie:

// Example program 
#include <iostream> 
#include <string> 

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

void foo(int &a) 
{ 
    cout << a << endl; 
} 

int main() 
{ 
    int a = 5; 
    foo(a); 
}