tableau a 2 dimensions en c++

Version imprimable

[*]tableau a 2 dimensions en c++

Bonjour,
je voudrais faire un tableau en 2 dimensions en c++.
voici l'equivalent en C de ce que je voudrais faire:
Code:

1 2 3 4 5 6 7 8 int ** m_pHoleMap; m_pHoleMap=(int **)malloc(sizeof(int*)*nbLines); for(int i=0;i<nbLines;i++){ m_pHoleMap[i]=(int*)malloc(sizeof(int)*nbColumns); for(int j=0;j<nbColumns;j++) m_pHoleMap[i][j]=-1; }
mais le malloc ca fait pas trop C++.
J'ai pense a un truc du style:
Code:

1 2 int ** m_pHoleMap=new int[nbLines][nbColumns];
mais ca ne marche pas.
Si vous avez des suggestions.
Merci d'avance

Salut,

Inspire toi de ça :
Code:

1 2 3 4 5 6 7 8 int** m_pHoleMap=new int*; for (int i = 0; i< nbLignes; i++) { for (int j= 0; j<nbColumns; j++) { m_pHoleMap[i][j] = -1; } }
Ce code créé une matrice et remplit toutes ses cases avec -1 comme tu t'en doutais ;)

Berk. Pourquoi ne pas utiliser des vectors de vectors ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
std::vector <std::vector <int> > tab2D;
const size_t nbLignes = 5;
const size_t nbColonnes = 6;
tab2D.resize (nbLignes); // On crée un tableau de 5 lignes
 
for (size_t i = 0 ; i < nbLignes ; ++i)
{
   tab2D.resize (nbColonnes); // Dans chaque ligne, 6 colonnes
      for (size_t j = 0 ; j < nbColonnes ; ++j)
      {
         tab2D[i][j] = -1;
      }
}

EDIT : ou plus simplement :

Code:

1
2
3
4
5
6
7
8
9
const size_t nbLignes = 5;
const size_t nbColonnes = 6;
std::vector <std::vector <int> > tab2D (nbLignes, nbColonnes);
 
   for (size_t i = 0 ; i < nbLignes ; ++i)
      for (size_t j = 0 ; j < nbColonnes ; ++j)
      {
         tab2D[i][j] = -1;
      }

J'avais un doute mais ça marche aussi.

salut

Code:

1
2
3
4
5
6
7
8
int** m_pHoleMap=new int*;
for (int i = 0; i< nbLignes; i++) 
{
   for (int j= 0; j<nbColumns; j++)
   {
       m_pHoleMap[i][j] = -1;
   }
}

tu t'es trompé dans les new :aie:

Code:

1
2
3
4
5
6
7
8
9
int** m_pHoleMap=new int*[nbLignes];
for (int i = 0; i< nbLignes; i++) 
{
   m_pHoleMap[i] = new int[nbColumns];
   for (int j= 0; j<nbColumns; j++)
   {
       m_pHoleMap[i][j] = -1;
   }
}

et pour desallouer

Code:

1
2
3
4
5
6
7
8
9
int** m_pHoleMap=new int*;
for (int i = 0; i< nbLignes; i++) 
   {
      delete [] m_pHoleMap[i];
   }
delete [] m_pHoleMap;
m_pHoleMap = NULL;// ne sert pas vraiment
 
}

28/06/2007, 23h45
Luc Hermitte

Pour ceux qui veulent faire des new[] (N +1), la réponse correcte est dans la FAQ.

Sinon rien ne vaut la réutilisation de ce qui a déjà été intensément validé : vector<vector<>>, boost::multi_array, stlsoft::arraynd (?), Blitz++, boost.ublas, Newmat, ...
29/06/2007, 09h58
r0d

En effet, boos::multi_array est trés pratique.
Sinon, pour rester dans la STL, tu peux jeter un coup d'oeil à ce post ;)
29/06/2007, 13h43
smashy

Citation:

Envoyé par Luc Hermitte

Sinon rien ne vaut la réutilisation de ce qui a déjà été intensément validé : vector<vector<>>, ...

Le vector< vector<> > n engendre t il pas des reallocation en cascade ? :

que le premier vecteur doit etre realloue , il implique une recopie de sont contenu donc allocation pour le nouveau vecteur + copie + liberation de l ancien vecteur
29/06/2007, 13h46
coyotte507

sinon si tu veux un statique tu peux faire

Code:

int mp_holemap[nblignes][nbcolonnes]

Je crois que par contre si tu mets "strict ISO c++" en option de compilation ca marche pas
29/06/2007, 13h51
Laurent Gomila

Citation:

Le vector< vector<> > n engendre t il pas des reallocation en cascade ? :

que le premier vecteur doit etre realloue , il implique une recopie de sont contenu donc allocation pour le nouveau vecteur + copie + liberation de l ancien vecteur

Quelles réallocations ? Les dimensions sont fixes.

Citation:

Je crois que par contre si tu mets "strict ISO c++" en option de compilation ca marche pas

Normal, ce n'est pas du C++ valide. Ca n'est valide qu'en C99.

[QUOTE=Laurent Gomila]Quelles réallocations ? Les dimensions sont fixes.
[QUOTE]

Dans un cas plus generale

Code:

1
2
3
4
5
6
7
8
9
10
vector< vector<int> >  v;
 
v.push_back( vector<int>() );
 
v[0].push_back(1);
v[0].push_back(2);
v[0].push_back(3);
v[0].push_back(4);
 
v.push_back( vector<int>() ); // cet appel , si il entraine un redimensionnement de 'v' va impliquer une copie de v[0] et donc une allocation + liberation ????

29/06/2007, 15h10
Laurent Gomila

Je parlais du cas présent.
29/06/2007, 22h37
sylvain.cool

Merci les gars, c'est exactement ce que je cherchais!