Discussion :

[boubyx.G]

Bonjour à tous et merci à ceux qui auront la gentillesse de m'aider.
Je cherche à créer un tableau bidimensionel (matrice) grâce à un pointeur qui pointe sur un tableau de pointeur qui pointent eux meme sur des tableaux de char.
Alors ca parait un peu loufoque, pourquoi ne pas utiliser un tableau bidimensionel basique, tout simplement pour le gérer en mémoire dynamique.

Donc voila j'ai une struct matrice qui rassemble deux int m (nombre de lignes) et n (nombre de colonnes) et un pointeur pour un tableau de pointeur sur des chars.
J'ai mis une image pour mieux expliquer la chose (qui est soit dit en passant un peu tordue).


Voila le source :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
Matrice.cpp:

/**
 * @file Matrice.cpp
 * Projet Projet-Le fil D'Ariane
 * @author l'équipe pédagogique 
 * @version 1 - 23/12/05
 * @brief Composant de pile avec capacité
 * Structures de données et algorithmes - DUT1 Paris 5
 */
#include <iostream>
using namespace std;
#include <fstream>
#include "Item.h"
#include "Matrice.hpp"

ici allocation de la matrice qui me rend fou
void Im(Matrice& M){
	M.tab=new Item*[M.m];
	for(int i=0;i<M.m;i++)
	{
		M.tab[i]=new char[M.n];
		}
}
//ici allocation de la matrice qui me rend fou			
Matrice.hpp:	

#ifndef _MATRICE_HPP_
#define _MATRICE_HPP_
#include "Item.h"
struct Matrice{
	int m,n;
	Item** tab; };
//ici declaration de super pointeur pour allocation dynamique

void Im(Matrice& M);


#endif //_MATRICE_HPP_
	
Item.h:
#ifndef _ITEM_
#define _ITEM_

/**
 * @file Item.h
 * Projet sem05-tp-Cpp4
 * @author l'équipe pédagogique 
 * @version 1 23/12/05
 * @brief Spécialisation du type Item
 * Structures de données et algorithmes - DUT1 Paris 5
 */

#include "Position.h"
typedef char Item;

#endif

tes.cpp:
#include <iostream>
#include <fstream>
using namespace std;
#include "Matrice.hpp"
#include "Item.h"

int main(){
	
	      int m,n;
	      Matrice M;
	      ifstream Ma;
	      char nom[45];
	      cout<< "quel est le nom du fichier a ouvrir?";
	      cin >> nom;
	      Ma.open(nom,ios::in);
	      if(Ma.fail()){
		      cout<<"bug";
		      exit(1);}
	      cout<< "nombre de lignes?";
	      cin >> m;
	      M.m=m;
	      cout<<"nombre de colonnes?";
	      cin >>n;
	      M.n=m;
	     Im(M);
	
	     Ma.close();
	
	     return(0);
}

Voila voila je pense que mon source est bon mais lorsque je débogue avec Eclipse le pointeur tab ne prend pas de structure matricielle mais simplement un pointeur sur un pointeur sur un char.
Encore merci d'avance de votre aide.

[jobherzt]

tu veux dire que le debouggeur te dit que ta variable n'est qu'un pointeur sur un pointeur sur un char ?? j'ai envie de te demander ou est le probleme, vu que c'est exactemant ce que c'est a priori... y a t il un plantage ou une erreur dans ton code ? en le survolant, il ne me semble pas qu'il y ait de probleme..

[boubyx.G]

Le problème que j'ai en fait c'est que la je ne peux stocker qu'une variable alors que je veux en stocker m*n vois tu mais apparemment ca fonctionne normalement.
Merci de ta rapidité

[jobherzt]

euh.. tu me dis a la fois que tu as un probleme et que ca fonctionne normalement... que dois je en deduire ?

[Luc Hermitte]

Je vois bien quantité de problèmes, mais pas là où cela te chagrine.

Un "T**" est un pointeur de pointeurs. Tu afficher les choses de façon plus intelligente, il faut voir avec ton débuggueur si tu peux rajouter des "hooks" pour te simplifier l'analyse.

[boubyx.G]

C'est bon en fin de comtpe ca fonctionne super bien, c'est le compilateur qui me donnait une représentation erronée du tableau de pointeur.
Desole de vous avoir dérangé pour rien.

[epsilon68]

je pense qu'il faudrait plutot un tableau lineaire qu'un tableau 2 dimensions.

au lieu de T[N][N]
d'avoir T[N*N]

[jobherzt]

c'est le compilateur qui me donnait une représentation erronée du tableau de pointeur.

est tu sur que ca n'est pas toi qui a une conception erronée de ce qu'est un tableau en C++ ?

[boubyx.G]

Ouais je pense que c'etait moi, parcequ'en fait un il ne montre qu'un pointeur a la fois ce qui est logique. Merci beaucoup de votre aide.
J'ai pas le droit au tableau T[N*N], je suis en etudes et la facon de faire la matrice nous a été imposée.

[jobherzt]

effectivement. mais la difference est mince, sace qu'un tableau T[N*N], ou un tableau T[N][N], ne sont jamas que des pointeurs "deguisés".

[epsilon68]

effectivement. mais la difference est mince, sace qu'un tableau T[N*N], ou un tableau T[N][N], ne sont jamas que des pointeurs "deguisés".

la difference n'est pas mince, dans un cas la matrice est un tableau de memoire contigue, dans un autre N petits tableaux.

[Laurent Gomila]

la difference n'est pas mince, dans un cas la matrice est un tableau de memoire contigue, dans un autre N petits tableaux.

Une fois compilé c'est exactement la même chose, au contraire. La différence tient plus dans le type de la chose et la manière dont on s'en sert.

[epsilon68]

Une fois compilé c'est exactement la même chose, au contraire. La différence tient plus dans le type de la chose et la manière dont on s'en sert.

ok ...

... en ecrivant T[N][M] c'est pour reprendre le schema explicatif du premier post,
par pour designer la syntaxe d'initialisation en C/C++

d'ailleurs vu comme ca T[N] ou T[N][M] ne sont valable que si N et M sont connu a la compilation ce qui n'etait absolument pas le cas.

Mes excuses si on n'est pas toujours tres clair.

il vaut mieux:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int *matrice = new int[N*M]

que:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int **matrice = new int*[N]
for( int i=0 ; i<N; i++ ) { matrice[i] = new int[M]; }

sans compter le destructeur, la recopie, l'initialisation, les allocations dynamiques en cascade.....

bref sans hesiter la premiere solution...

[Médinoc]

Je préfère un mix des deux: Une allocation par dimension.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
//Attention, c'est de l'approximatif
int **pDim1 = new int*[N];
int * pDim0 = new int[N*M];
for( int i=0 ; i<N; i++ )
{
	pDim1[i] = &pDim0[i*M];
}

[Médinoc]

Et encore, en trichant un peu avec malloc() ou new char[], on peut même faire une seule allocation pour le tout, mais je le déconseille, surtout en C++ (il me semble qu'un delete[] doit forcément être du même type que le new[], mais je n'en ai pas confirmation)

[Luc Hermitte]

@Médinoc. Cela ne pose aucun problème. Un pointeur pour le buffer d'octets : celui de l'alocation et de la désallocation. Plus un pointeur pour la vue sur le tableau de lignes.

[epsilon68]

Je préfère un mix des deux: Une allocation par dimension.

Mais a quoi ca sert ? si on redefinit l'operateur [] alors on a le meme resultat ...

[Médinoc]

Là, je parlais de tableaux purs.
En effet, encapsulé dans une classe, rédéfinir l'opérateur peut être pas mal.
Encore que, je me demande si ça marche pour plus de deux dimensions...

[epsilon68]

Là, je parlais de tableaux purs.
En effet, encapsulé dans une classe, rédéfinir l'opérateur peut être pas mal.
Encore que, je me demande si ça marche pour plus de deux dimensions...

oui il suffit de retourner un pointer pour permettre encore l'operateur []

edit: peut-etre que ce n'est finalement pas si simple, mais certainement pas insurmontable, ... pour un prochain post ?

a+

[dudule75]

bonjour boubyx.G,
je me suis lancé il y a peu dans la programmation en C++. Afin de pouvoir à terme programmer mes propres jeux.
Afin de me familiariser avec les algos de recherche de chemins, j'ai essayé de résoudre le problème du fil d'ariane (très connu) sans succès. Alors, j'aurai souhaité si possible pouvoir visualiser ton projet pour voir comment tu t'y ai pris.
Merci d'avance et à+