Capisco che il parametro del modello non di tipo dovrebbe essere un'espressione integrale costante. Qualcuno può far luce perché è così?
template <std::string temp>
void foo()
{
// ...
}error C2993: 'std::string' : illegal type for non-type template parameter 'temp'.
Capisco cos'è un'espressione integrale costante. Quali sono le ragioni per non consentire tipi non costanti std::stringcome nello snippet sopra?
Risposte:
Il motivo per cui non puoi farlo è perché le espressioni non costanti non possono essere analizzate e sostituite durante la compilazione. Potrebbero cambiare durante il runtime, il che richiederebbe la generazione di un nuovo modello durante il runtime, il che non è possibile perché i modelli sono un concetto in fase di compilazione.
Ecco cosa consente lo standard per i parametri del modello non di tipo (14.1 [temp.param] p4):
Un parametro-modello non di tipo deve avere uno dei seguenti tipi (facoltativamente qualificati per cv):
- tipo integrale o di enumerazione,
- puntatore a oggetto o puntatore a funzione,
- lvalore riferimento all'oggetto o lvalore riferimento alla funzione,
- puntatore al membro,
std::nullptr_t.
Non è permesso.
Tuttavia, questo è consentito:
template <std::string * temp> //pointer to object
void f();
template <std::string & temp> //reference to object
void g();Vedere §14.1 / 6,7,8 in C ++ Standard (2003).
Illustrazione:
template <std::string * temp> //pointer to object
void f()
{
cout << *temp << endl;
}
template <std::string & temp> //reference to object
void g()
{
cout << temp << endl;
temp += "...appended some string";
}
std::string s; //must not be local as it must have external linkage!
int main() {
s = "can assign values locally";
f<&s>();
g<s>();
cout << s << endl;
return 0;
}Produzione:
can assign values locally
can assign values locally
can assign values locally...appended some stringstd::stringpuntatore o oggetto di riferimento. Se quella variabile fosse locale, potresti ottenere indirizzi diversi ogni volta che viene chiamata la funzione.
Devi essere in grado di manipolare gli argomenti del modello
template <std::string temp>
void f() {
// ...
}
f<"foo">();
f<"bar">(); // different function!?Ora un impl dovrebbe creare una sequenza di caratteri univoca per una std::stringo, per quella materia, qualsiasi altra classe arbitraria definita dall'utente, memorizzando un valore particolare, il cui significato non è noto all'implementazione. Inoltre, il valore di oggetti di classe arbitrari non può essere calcolato in fase di compilazione.
Si prevede di considerare la possibilità di consentire tipi di classi letterali come tipi di parametri del modello per post-C ++ 0x, che vengono inizializzati da espressioni costanti. Questi potrebbero essere alterati facendo modificare ricorsivamente i membri dei dati in base ai loro valori (per le classi base, ad esempio, possiamo applicare la profondità prima, attraversamento da sinistra a destra). Ma sicuramente non funzionerà per classi arbitrarie.
Un argomento modello non di tipo fornito all'interno di un elenco di argomenti modello è un'espressione il cui valore può essere determinato in fase di compilazione. Tali argomenti devono essere:
espressioni costanti, indirizzi di funzioni o oggetti con collegamento esterno o indirizzi di membri di classi statiche.
Inoltre, i letterali stringa sono oggetti con collegamento interno, quindi non è possibile utilizzarli come argomenti del modello. Non è nemmeno possibile utilizzare un puntatore globale. I letterali in virgola mobile non sono consentiti, data l'ovvia possibilità di errori di arrotondamento.