C++: vettore di classe template

Question

ho una classe template chiamato cellulare come segue: -

template<class T>class Cell 
{ 
    string header, T data; 
} 

Ora voglio un'altra classe denominata Row. La riga avrà un vettore chiamato Celle in modo tale da poter aggiungere elementi di tipo Cella e Cella a quel vettore. È possibile?

Se sì, come posso farlo? Grazie in anticipo.

Answer 1

Con dettaglio in più che ci hai fornito, le prime due risposte non funzioneranno. Quello che ti serve è un tipo noto come variante per la cella e quindi puoi avere un vettore di quelli. Ad esempio: -

enum CellType 
{ 
    Int, 
    Float, 
    // etc 
}; 

class Cell 
{ 
    CellType type; 
    union 
    { 
    int i; 
    float f; 
    // etc 
    }; 
}; 

class Vector 
{ 
    vector <Cell> cells; 
}; 

Questo, tuttavia, è un problema aggiungere nuovi tipi poiché richiede molto codice da mantenere. Un'alternativa potrebbe utilizzare il modello cella con una classe base comune: -

class ICell 
{ 
    // list of cell methods 
}; 

template <class T> 
class Cell : public ICell 
{ 
    T data; 
    // implementation of cell methods 
}; 

class Vector 
{ 
    vector <ICell *> cells; 
}; 

questo potrebbe funzionare meglio quando si dispone di meno codice inizialmente per aggiornare per aggiungere un nuovo tipo di cellula, ma è necessario utilizzare un tipo di puntatore nelle cellule vettore. Se hai memorizzato la cella in base al valore, vector <ICell>, perderai i dati a causa di object slicing.

Answer 2

Qualcosa di simile?

template<class T> 
class Row 
{ 
private: 
    std::vector<Cell<T> > cells; 
}; 

OK, questa risposta non è corretta.

Quindi, se si desidera archiviare in una cella vector diverse, è necessario utilizzare un'identificazione di tipo dinamica (è possibile utilizzare un puntatore di classe base e archivio su di esso in vettoriale, che utilizza solo funzioni virtuali, sovrascritte in tutte le classi derivate, è possibile memorizzare qualcosa come boost::any e salvare alcuni type-identification per ogni elemento inserito, per convertirli in un tipo reale e lavorarci sopra).

Answer 3

L'altra risposta è buona, ma probabilmente voleva:

template<class T> 
class Row 
{ 
private: 
    class Cell { 
     string header; 
     T data; 
    } 

    std::vector<Cell> cells; 
    ... 
} 

Answer 4

Il motivo per cui questo non è possibile in C++, ma possibile in Java/Python è perché: in C++ vettore, di stoccaggio del contenitore STL (restituito da vector :: dati()) contiene tutte le istanze di oggetti sequencially confezionato. In cui ogni elemento deve avere la stessa dimensione. Questo rende l'indirizzamento rapido e conveniente. Pertanto, si supponga di definire una classe modello A,

template <class T> 
class A{ 
    int id; 
    T obj; 
}; 

La sua dimensione dipenderà dalla variabile di modello "T obj". Spingere la stessa classe A di un diverso tipo di modello T renderà ogni elemento nel vettore di dimensioni diverse, quindi, questo è impossibile. L'unico modo è usare il vettore di shared_ptr o unique_ptr di una classe base. Sia shared_ptr che unique_ptr sono supportati da C++ 11 e Boost. Ogni elemento di classe derivata può avere diversi tipi di modello. In questo modo, quando viene chiamato il distruttore del puntatore della classe base, verrà richiamato il distruttore della classe derivata. Ad esempio,

#include <memory> 
#include <vector> 
#include <iostream> 
#include <string> 

using namespace std; 

class A{}; 

template <class T> 
class AImpl : public A{ 
public: 
    T obj; 
    AImpl(T _obj):obj(_obj){} 
    ~AImpl(){ 
     cout << "Deleting " << obj << endl; 
    } 
}; 

int main(int argc, char** argv) 
{ 
    AImpl <string>* a1 = new AImpl <string> ("string1234"); 
    AImpl <int>* a2 = new AImpl <int> (1234); 
    AImpl <double>* a3 = new AImpl <double> (1.234); 
    vector <shared_ptr<A>> As; 
    As.push_back(shared_ptr<A>(a1)); 
    As.push_back(shared_ptr<A>(a2)); 
    As.push_back(shared_ptr<A>(a3)); 
} 

Ricordarsi di compilare con -std = C++ 11 per abilitare C++ 11.

uscita:

Deleting string1234 
Deleting 1234 
Deleting 1.234 

E si ottiene ciò che si vuole! :)

In Java/Python, ogni variabile oggetto di classe è in realtà un puntatore, quindi, una matrice Java di A o una lista Python di A è equivalente a una matrice C++ di puntatori di A. Quindi, si ottiene essenzialmente la stessa funzionalità senza creare esplicitamente shared_ptrs.