utilizzando typedef nell'istanza modello e nella dichiarazione modello esterno

Question

Ci sono due casi in cui typedef mi confonde quando si tratta di extern template declaration e explicit template instantiation.

Per illustrare i due vedi sotto 2 esempi di frammenti di codice.

consideri seguente esempio (caso 1):

// suppose following code in some cpp file  
template <typename T> 
    struct example 
{ 
    T value; 
}; 

// valid typedefs 
typedef example<int> int_example; 
typedef example<std::string> string_example; 

// explicit instantiation using above typedefs 
template class int_example; // -> compile time error 
template class string_example; // -> compile time error 

// instead we need to use type names 
template class example<int>; // -> OK 
template class example<std::string>; // -> OK 

// QUESTION 1: Why does this work however? is this valid code? 
typedef std::string type_string; 
template class example<type_string>; 

Perché l'template class example<type_string> lavoro con typedef? e perché è valido mentre template class string_example non lo è?

consideri seguente esempio (Caso 2):

// suppose following code is in some header file 
template <typename T> 
struct example 
{ 
    T value; 
}; 

// valid typedefs 
typedef std::string type_string; 
typedef example<type_string> string_example; 

// Explicit instantiation declaration 
// QUESTION 2: Is this valid code? if not why not? 
extern template string_example; // -> at least this compiles, but is it OK? 

Come messo in discussione nel commento di cui sopra, è valido per utilizzare typedef in extern template declaration, come nell'esempio di cui sopra, e perché questo compilare a differenza del Case1 dove non lo fa.

Ho letto di casi simili ma nessuno fornisce la risposta dettagliata a sopra 2 domande. l'elaborazione dettagliata è molto apprezzata!

Answer 1

template class int_example; 

non è legale. Dalla C++ 11 Stanard:

14.7.2 istanziazione esplicita

2 La sintassi per istanziazione esplicita è:

esplicita-esemplificazione:
extern _opttemplatedichiarazione

Esistono due forme di istanziazione esplicita: una definizione di istanziazione esplicita e una dichiarazione di istanziazione esplicita. Una dichiarazione di istanziazione esplicita inizia con la parola chiave extern.

3 Se l'istanza esplicita è per una classe di classe o di un membro, il elaborato di tipo-specifier nel dichiarazione comprendono un semplice-template-id.

semplice-template-id è definita nella sezione A.12 modelli come:

semplice-template-id:
template-name<modello-argument-list _opt>

int_example non si qualifica come un simple-template-id.
example<int> si qualifica come ID modello semplice.

Tuttavia, da questa logica,

extern template string_example; 

non è legale sia. Non so come funzioni per te. Ho avuto il seguente errore quando ho provato a compilare una riga simile in g ++ 4.9.3.

socc.cc:15:31: error: expected unqualified-id before ‘;’ token 
extern template string_example; // -> compile time error