C++ - Tableau à deux dimensions vectoriel d'objets

Question

Comme suggéré here J'ai corrigé mon tableau 2D de nombres pour le faire fonctionner avec la classe Vector.

fichier d'en-tête:

#include <vector> 

typedef std::vector<int> Array; 
typedef std::vector<Array> TwoDArray; 

Et voici comment il est utilisé:

TwoDArray Arr2D; 

// Add rows 
for (int i = 0; i < numRows; ++i) { 
    Arr2D.push_back(Array()); 
} 

// Fill in test data 
for (int i = 0; i < numRows; i++) {  
    for (int j = 0; j < numCols; j++) { 
     Arr2D[i].push_back(ofRandom(0, 10));   
    } 
} 

// Make sure the data is there 
for (int i = 0; i < numRows; i++) {  
    for (int j = 0; j < numCols; j++) { 
     std::cout << Arr2D[i][j] << ' '; 
    } 
std::cout << '\n'; 
} 

Ma question est, comment puis-je faire la même chose pour les objets personnalisés au lieu de numéros int? J'ai essayé un changement d'int par MyObject et en utilisant push_back (new MyObject()); mais cela ne fonctionne pas correctement lorsque j'essaie d'accéder à ses fonctions.

Merci d'avance.

Answer 1

new MyObject() retournera un pointeur à la nouvellement créé une instance de classe MyObject. Si vous avez créé un vector<MyObject> alors vous devez faire quelque chose comme push_back(MyObject()).

Answer 2

vous devez changer

typedef std::vector<int> Array; 
typedef std::vector<Array> TwoDArray; 

à

typedef std::vector<MyObject> Array; 
typedef std::vector<Array> TwoDArray; 

Answer 3

Dans les grandes lignes:

struct MyObject {}; 

typedef std::vector<MyObject> Array; 
typedef std::vector<Array> TwoDArray; 

// stuff 

Arr2D[i].push_back(MyObject()); 

Notez que pour stocker des choses dans un vecteur ils doivent être copiable et cessible.

Answer 4

Essayez ceci:

template<class T> 
struct Array2D { 
    vector<vector<T>> Array; 
}; 

maintenant vous pouvez le déclarer à tout objet comme si

Array2D<MyObject>::Array array; 

ou même

Array2D<MyObject*>::Array array; 

et continuer votre journée comme d'habitude ...

Être un que lorsque vous affectez un objet à un conteneur stl, il doit implémenter, un constructeur par défaut, un constructeur de copie et un opérateur de surcharge = (const et non-const), sinon vous devez insérer un pointeur sur l'objet.

Answer 5

Si j'étais vous, j'utiliserais eux-mêmes un tableau de pointeurs au lieu d'un objet (mais vous devrez vous occuper de la désallocation avant de faire votre "clear()").

typedef std::vector<std::vector<myObject* > > 2DArray; 

2DArray A; 
for (int i=0; i<numRows;++i) A.push_back(std::vector<myObject* >(numColumns)); 

myObject* M = new myObject(...); 
A[row][column] = M; 

Answer 6

Puisque vous êtes à la recherche de la meilleure approche de conception, pourquoi ne pas suivre les conseils de C++ FAQ Lite et de rendre votre réseau dense (plutôt que haillons). Vous ne vous attendez pas à devoir manipuler des rangées de tailles différentes, n'est-ce pas?

#include <iostream> 
#include <random> 
#include <vector> 

template<typename T> 
class TwoDArray { 
     std::vector<T> data; 
     const size_t cols; 
public: 
     TwoDArray(size_t R, size_t C) : data(R*C), cols(C) {} 
     T operator()(size_t r, size_t c) const { return data[cols*r+c]; } 
     T& operator()(size_t r, size_t c) { return data[cols*r+c]; } 
}; 

int main() 
{ 
     // Make it 
     const size_t numRows = 10; 
     const size_t numCols = 10; 
     TwoDArray<int> Arr2D(numRows, numCols); 

     // Fill in test data 
     std::random_device rd; 
     std::mt19937 eng(rd()); 
     std::uniform_int_distribution<> unif(0,9); 
     for (size_t i=0; i<numRows; ++i) 
      for (size_t j=0; j<numCols; ++j) 
       Arr2D(i,j) = unif(eng); 

     // Make sure the data is there 
     for (size_t i = 0; i < numRows; i++) { 
      for (size_t j = 0; j < numCols; j++) { 
       std::cout << Arr2D(i,j) << ' '; 
      } 
      std::cout << '\n'; 
     } 

} 

Ou vous pourriez même faire partie de la taille du type, tout comme std::array.