È possibile sovraccaricare legalmente una stringa letterale e const char *?

Question

E 'possibile in C++ 11 sovraccaricare const char* e stringhe letterali (const char[])? L'idea è di evitare di chiamare strlen per trovare la lunghezza della stringa quando questa lunghezza è già nota.

pause

questo frammento di G ++ 4.8 e Clang ++ 3.2:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

template<typename T, int N> 
void length(const T(&data)[N]) { 
    printf("%u[]\n", N - 1); 
} 

template<typename T> 
void length(const T* data) { 
    printf("*%u\n", (unsigned)strlen(data)); 
} 

int main() { 
    length("hello"); 
    const char* p = "hello"; 
    length(p); 
    return 0; 
} 

Error (Clang):

test2.cpp:16:3: error: call to 'length' is ambiguous 
    length("hello"); 
    ^~~~~~ 
test2.cpp:6:6: note: candidate function [with T = char, N = 6] 
void length(const T(&data)[N]) { 
    ^
test2.cpp:11:6: note: candidate function [with T = char] 
void length(const T* data) { 
    ^
1 error generated. 

Hacked un po ', e questo sembra funzionare:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

template<typename T, int N> 
void length(const T(&data)[N]) { 
    printf("%u[]\n", N - 1); 
} 

template<typename T> 
void length(T&& data) { 
    printf("*%u\n", (unsigned)strlen(data)); 
} 

const char *foo() { 
    return "bar"; 
} 

int main() { 
    length("hello"); 
    const char* p = "hello"; 
    length(p); 
    length(foo()); 
    return 0; 
} 

È questo C++ 11 valido? La stringa letterale sembra sovraccaricare su T&& quando viene rimossa la specializzazione dell'array. Che cosa causa questa ambiguità da risolvere, ma non quella del primo frammento di codice?

Answer 1

Nel primo caso, durante la risoluzione di sovraccarico si ha una corrispondenza perfetta che non richiede alcuna conversione da una conversione di matrice a puntatore (che è nella categoria "trasformazione lvalue", insieme a lvalue a rvalue e funzione alla conversione puntatore). Una differenza che viene fatta solo da una trasformazione lvalue non è sufficiente per la risoluzione del sovraccarico per scegliere un vincitore.

Nel secondo caso, durante la risoluzione di sovraccarico, entrambe le funzioni hanno lo stesso tipo di parametro. Quindi l'ordinamento parziale come ultima risorsa rileva che il secondo modello accetta tutti gli argomenti che gli vengono mai passati, mentre il primo modello accetta solo matrici. Quindi il primo modello nel secondo caso viene trovato più specializzato e preso.

---

Come per la tua altra domanda - no, il sovraccarico specifico per stringhe letterali non è possibile. Con le stesse dimensioni catturerai sempre array della stessa dimensione.