ou qu'elle est l'erreur??

5 réponses

jjabon

15/11/2003 à 21:28

bonjour, voila, je commence dans le c++ et la , je cale, je trouve pas
mon erreur, un peu d'aide serai la bien venue.

ce code est "cense" initialisé une matrice dinamique, y ecrire a chaque
position un nombre, et ensuite l'afficher, mais mon code reste calé???
merci de votre aide
a+++

#include <iostream>
using namespace std;

main()
{
int cpt = 0;
int a,b,c;
cin >>a>>b>>c;

int ***V = new int **[a];
for(int i=0;i<a;++i)
{
V[a] = new int*[b];
for(int j=0;j<b;++j)
V[a][b] = new int[c];
}
//-*---------------------------------

for(int i=0;i<a;++i)
{
for(int j=0;j<b;++j)
{
for(int k=0;k<c;++k)
{
V[i][j][k] = cpt;
cpt++;
}
}
}
//-------------------------------------
for(int i=0;i<a;++i)
{
for(int j=0;j<b;++j)
{
for(int k=0;k<c;++k)
cout << V[i][j][k]<<" ";
cout << endl;
}
cout << "----------------------" << endl;
}

cin >> cpt;

}

5 réponses

Christophe Lephay

15/11/2003 à 21:59

jjabon wrote:

bonjour, voila, je commence dans le c++ et la , je cale, je trouve
pas mon erreur, un peu d'aide serai la bien venue.

ce code est "cense" initialisé une matrice dinamique, y ecrire a
chaque position un nombre, et ensuite l'afficher, mais mon code reste
calé??? merci de votre aide

Que veux-tu dire par "reste calé" ?

Indépendemment de celà, essaie d'utiliser les std::vector as soon as
possible, ils te libèrent de tout l'aspect allocation dynamique et
fournissent, de plus, des accès plus robustes (avec vérification des
bornes).

C'est vrai que c'est un peu lourd à écrire pour des tableaux
tri-dimensionnels, mais bon, c'est un autre débat ;)

Chris

Vincent Lascaux

15/11/2003 à 22:15

#include <iostream>
using namespace std;

main()
{
int cpt = 0;
int a,b,c;
cin >>a>>b>>c;

int ***V = new int **[a];

Bon, normalement tu aurais du ecrire (en C++)
std::vector< std::vector< std::vector< int > > > V(a, std::vector<
std::vector<int> >(b, std::vector<int>(c)));
Ce qui aurait déclaré la matrice et l'aurait dimensionné à la bonne taille.

for(int i=0;i<a;++i)
{
V[a] = new int*[b];

V[i]=new int*[b];

for(int j=0;j<b;++j)
V[a][b] = new int[c];

V[i][j] = new int[c];

}
//-*---------------------------------

for(int i=0;i<a;++i)
{
for(int j=0;j<b;++j)
{
for(int k=0;k<c;++k)
{
V[i][j][k] = cpt;
cpt++;
}
}
}
//-------------------------------------
for(int i=0;i<a;++i)
{
for(int j=0;j<b;++j)
{
for(int k=0;k<c;++k)
cout << V[i][j][k]<<" ";
cout << endl;
}
cout << "----------------------" << endl;
}

cin >> cpt;

for(int i=0;i<a; ++i)
{
for(int j=0;j<b; ++j)
delete[] V[i][j];
delete[] V[i];
}
delete[] V;

L'interet du vector, c'est que tu n'as pas à écrire ca non plus...

}

Fabien LE LEZ

15/11/2003 à 22:49

On Sat, 15 Nov 2003 22:15:30 +0100, "Vincent Lascaux"
wrote:

std::vector< std::vector< std::vector< int > > > V(a, std::vector<
std::vector<int> >(b, std::vector<int>(c)));

J'ai un doute, là : est-ce que ce qui suit a le même effet ?

std::vector< std::vector< std::vector< int > > > V
(a, std::vector<std::vector<int> >(b, c));

--
;-)

Vincent Lascaux

15/11/2003 à 23:20

std::vector< std::vector< std::vector< int > > > V(a, std::vector<
std::vector<int> >(b, std::vector<int>(c)));

J'ai un doute, là : est-ce que ce qui suit a le même effet ?

std::vector< std::vector< std::vector< int > > > V
(a, std::vector<std::vector<int> >(b, c));

Non. Ce que tu as écrit n'est pas valide
std::vector<T> a un constructeur avec deux parametres : la taille du vecteur
et une valeur (de type T) à mettre dans toutes les cases du vecteur.
Tu écris std::vector<std::vector<int> >(b, c), ce qui n'est valable que si c
est du type std::vector<int> (ce qui n'est pas le cas).
C'est vrai que ma ligne est pas tres claire. Mais aussi, quelle idée de
faire une matrice à 3 dimensions ;)
Je la réécrit avec des typedefs

typedef std::vector<int> Profondeur;
typedef std::vector<Profondeur> Colonne;
typedef std::vector<Colonne> Matrice;
Matrice V(a, Colonne(b, Profondeur(c)));

C'est mieux comme ca non ?

Fabien LE LEZ

15/11/2003 à 23:58

On Sat, 15 Nov 2003 23:20:19 +0100, "Vincent Lascaux"
wrote:

std::vector< std::vector< std::vector< int > > > V
(a, std::vector<std::vector<int> >(b, c));

Non. Ce que tu as écrit n'est pas valide
std::vector<T> a un constructeur avec deux parametres : la taille du vecteur
et une valeur (de type T) à mettre dans toutes les cases du vecteur.

Je crois me souvenir qu'il y a une règle particulière quand le type
contenu est int, et que

std::vector< std::vector< int > > v (3,4);

crée bien une matrice 3x4.

--
;-)

ou qu'elle est l'erreur??

5 réponses

Veuillez sélectionner un problème