Modello typedef per contenitore standard (senza specializzazione)?

Question

È possibile utilizzare typedef su un contenitore standard senza specializzarlo?

codice come questo funziona:

typedef std::vector<int> intVector; 

Ma per questo codice:

template <typename T> 
typedef std::vector<T> DynamicArray<T>; 

ottengo un errore:

template declaration of 'typedef'

E 'possibile fare questo in C++ ??

Answer 1

Sì, in C++ 11.

template <typename T> 
using DynamicArray = std::vector<T>; 

(Non che si dovrebbe utilizzare l'alias esatto.)

Answer 2

La soluzione comune (se non si utilizza C++ 11) è di fare questo:

template<class T> 
struct DynamicArray 
{ 
    typedef std::vector<T> Type; 
}; 

e usarlo come DynamicArray<Something>::Type.

Answer 3

Se il supporto del compilatore C++ 11:

template <typename T> 
using DynamicArray = std::vector<T>; 

altrimenti (C++ 98 anni o più) è possibile utilizzare una struttura di aiuto come il seguente

template<typename T> 
struct DynamicArray 
{ 
    typedef std::vector<T> type; 
}; 

e quindi utilizzare come

DynamicArray<int>::type my_array; 

Ereditare da std :: vector è una possibile soluzione ma tenere presente che i contenitori STL non hanno un distruttore virtuale. Vale a dire:

template <typename T> 
struct DynamicArray: vector<T> { ... }; 

int main() { 
    vector<int>* p = new DynamicArray<int>(); 
    delete p; // this is Undefined Behavior 
    return 0; 
} 

Answer 4

Questa sintassi non è valida in C++, non esiste alcuna funzione come "modello typedef".

template <typename T> 
typedef std::vector<T> DynamicArray<T>; 

Tuttavia, C++ 11 introduce una sintassi modello di alias che è quasi simile a questo:

template <typename T> 
using DynamicArray = std::vector<T>; 

In C++ 03 è possibile utilizzare un modello metafunction come:

template<class T> 
struct DynamicArray 
{ 
    typedef std::vector<T> type; 
}; 

Answer 5

per aggiungere la mia soluzione al mix

dal momento che la funzione C++ 11 non è supportato da Visual Studio ho deciso di appena ereditare std :: vector, usando questo per aggiungere alcune funzionalità:

template <typename T> 
class DynamicArray : public std::vector<T> { 
public: 
    DynamicArray& operator<<(const T& value) 
    { 
     push_back(value); 
     return *this; 
    } 
}; 

Ora oltre push_back, concatenamento è supportato anche:

DynamicArray<int> array; 
array << 1 << 2 << 3 << 4 << 5 << 6; 

Non so se un tale approccio può avere degli svantaggi non intenzionali , quindi se ne conosci qualcuno, per favore condividili!