C++

pointeur de tableau 2D d'entiers...

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : pointeur de tableau 2D d'entiers...

beuted

Bonjour, (je créé un nouveau topic pour pas encombrer le précédent)
J'ai un souci avec un passage de fonction en paramètre j'ai beau retourner le problème dans tout les sens ça veut pas compiler...

J'ai un fichier Map.h dans lequel je créé une class avec en private : (ligne 30)

Code :

private:
int terrain[12][12];

Et en public la fonction qui renvoi ce tableau :

Code :

public
int** RenvoitTerrain();

Avec comme code dans le Map.cpp

Code :

int** Map::RenvoitTerrain()
{
return terrain;
}

Ma fonction utilisant cette class comporte #include "Map" et après avoir créé un objet maCarte de type Map demande :

Code :

Rect_source.x = (*maCarte.RenvoitTerrain())[j][i]*LARGEUR_TILE;

L'erreur que renvoi le compilateur :
map.cpp:30:10: error: cannot convert ‘int (*)[12]’ to ‘int**’ in return
make: *** [map.o] Erreur 1

J'ai beau changer int** en int[12]* il me lève une autre erreur, et ainsi de suite :pt1cable:

Merci d'avance.

Publicité

Xavier_OM

Monarchiste régicide (fr quoi)

Un tableau C et un pointeur sont deux choses différentes : int[] et int* sont différents, int[][] et int** sont différents aussi. Quand tu écris return terrain; tu ne dois pas t'attendre à une conversion magique entre ton int terrain[12][12] et ton type de retour int**.

Je vais tenter de dresser un portrait de la situation mais tu vas vite voir que C++ est un langage (très complexe) qui n'aime pas trop les tableaux C, qui sont du coup difficiles à manipuler surtout quand ils ont plusieurs dimensions.
De base C++ "dégrade" le type tableau (à une dimension) qu'on lui passe pour en faire un pointeur (ce comportement vient du C).
On peut donc écrire ce genre de chose :

Code :

int* getArray(int array[]) { // array est dégradé en int*
return array;
}

Note que je suis censé retourner un int* et que visiblement mon return array; ne pose pas de problème. C'est pour ça que je parle de dégradation, en fait c'est une autre écriture pour :

Code :

int* getArray(int* array) {
return array;
}

mais ce n'est pas un "vrai" passage de tableau en argument qu'on fait là si je puis dire. D'ailleurs si on veut passer un tableau d'int à 2 dimensions en paramètre, on ne peut pas écrire :

Code :

void foobar(int array[][]) { ... } // declaration of ‘array’ as multidimensional array must have bounds for all dimensions except the first

(le message d'erreur nous indique qu'une chose comme "void foobar(int array[][37]) { ... }" marcherait soit dit en passant).

De même si on veut retourner un tableau de ce genre, on ne peut pas écrire des trucs du genre :

Code :

int[][] getArray() { ... } // error: expected unqualified-id before ‘[’ token

Comment on fait alors ? Ben c'est compliqué

C'est pour ça que la plupart du temps :

soit les gens utilisent les collections de la stl comment std::vector<int>, qui sont les tableaux de C++ (par opposition à int[] qui sont les tableaux de C)
soit ils abandonnent l'idée d'utiliser "proprement" les types tableaux C et se rabattent sur des pointeurs ou des pointeurs de pointeurs. Mais comme type de retour pour une méthode publique d'une classe c'est franchement pas top. Quand on utilise ce genre de raccourcis il faut que ça reste en private mais il faut éviter d'exposer ce genre de cuisine interne publiquement.

Un exemple de méthode qui bosse vraiment avec un tableau de taille 5 (et uniquement 5), sans dégrader son type en pointeur :

Code :

int ( &fillArray( int (&arr)[5] ) )[5] { // no decay; argument must be size 5
return arr;
}
int foo[5];
fillArray(foo);

Je ne pense pas que ce genre de choses soit une bonne idée (syntaxe complexe, taille fixée, etc).
Dans la version la plus récente de C++ on peut faire la même chose avec une syntaxe moins cryptique, en utilisant des templates :

Code :

#include <array>
using namespace std;
array<int,5>& fillArray( array<int,5> &arr) {
return arr;
}
array<int,5> foo;
array<int,5> bar = fillArray(foo);

Mon conseil : fait toi une classe Terrain, qui n'utilise qu'en interne des pointeurs genre int** pour manipuler ton int[][]. Dans le reste de ton code après tu utilises cet objet Terrain, mais pas un int**, c'est trop casse-gueule

---------------
Il y a autant d'atomes d'oxygène dans une molécule d'eau que d'étoiles dans le système solaire.

Terminapor

I'll see you rise.

Pourquoi tu fais plutôt un accesseur sur le tableau ?

genre :

Code :

int Map::GetValueAt(int xx,int yy)
{
// Accès hors du tableau :
if (xx>12 || xx<0 || yy>12 || yy<0)
return -1;
return tableau[yy][xx]; // ou return tableau[xx][yy];
}

---------------
Perhaps you don't deserve to breathe

beuted

@Terminator : Nan en fait il me faut vraiment la valeur de tout le tableau pour pouvoir le manipuler "une couche au dessus".

@Mathieux : Merci pour ce cours détaillé
Je cerne mieux le problème maintenant, en fait comme que je le dis à Terminator, je voudrais utiliser ce tableau "une couche au dessus" dans la fonction qui utilise ma class Map. (Je suis donc obligé de faire mes magouilles sur ces deux étages)
En suivant ton idée, mettons que je déclare dans ma class (en private) mon tableau comme un int **, je fais ensuite une fonction qui retourne simplement tableau (int**).
J'ai deux questions :
- Comment j'initialise mon tableau ? (un malloc est nécessaire non ?)
- Comment j'appelle ma fonction RetourneTableau une couche au dessus? (simplement avec un maCarte.RetourneTableau() ?)

Message édité par beuted le 18-03-2012 à 10:58:34

Joel F

Real men use unique_ptr

ne pas oublier boost::array (ou std::array) qui permet de manipuler de stableaux C ave cune semantique de valeur correct.

beuted

@Mathieux je retire ma question j'ai trouvé un tuto très bien à ce sujet. http://h-deb.clg.qc.ca/Sujets/Dive [...] ux-2D.html
~~Le problème c'est que maintenant j'ai une belle seg fault~~ PROBLEME RESOLU je n'avais juste pas compris le principe du destructeur en fait, je ne pensais pas qu'il s'appliquait directement après le constructeur.

Voila mon constructeur et mon destructeur (tableau de type int**) :

Code :

#define LARGEUR_MAP 10
#define HAUTEUR_MAP 10
Map::Map()
{
terrain = new int* [LARGEUR_MAP];
for (int i = 0; i < LARGEUR_MAP; i++) {
terrain[i] = new int[HAUTEUR_MAP];
}
}
Map::~Map()
{
for (int i = 0; i < LARGEUR_MAP; i++)
delete [] terrain[i];
delete [] terrain;
}

Et ma fonction qui affiche mon terrain en utilisant le tableau d'entier, c'est la que ca seg fault)

Code :

void Map::afficherTerrain(SDL_Surface* surface, SDL_Surface* screen,int nombre_blocs_largeur,int nombre_blocs_hauteur)
{
int i,j;
SDL_Rect Rect_dest;
SDL_Rect Rect_source; // # recréé a chaque fois ?
Rect_source.w = LARGEUR_TILE;
Rect_source.h = HAUTEUR_TILE;
for(i=0;i<nombre_blocs_largeur;i++)
{
for(j=0;j<nombre_blocs_hauteur;j++)
{
Rect_dest.x = i*LARGEUR_TILE;
Rect_dest.y = j*HAUTEUR_TILE;
Rect_source.x = terrain[j][i]*LARGEUR_TILE;
Rect_source.y = 0;
SDL_BlitSurface(surface,&Rect_source,screen,&Rect_dest);
}
}
}

Lorque j'appelle maCarte.afficherTerrain(tile,ecran,10,10) ca seg fault ...

Message édité par beuted le 18-03-2012 à 13:28:50

Terminapor

I'll see you rise.

T'as pas initialisé les valeurs du tableau, je me trompe ?

---------------
Perhaps you don't deserve to breathe

beuted

Si si, dans mon constructeur.
Mais mon problème est résolu, j'ai juste laissé mon code au cas ou quelqu'un ai le même problème que moi tombe sur cette page.
Mon problème venait en fait de mon destructeur. Je l'ai supprimé et je l'ai remplacé par une fonction "libererTerrain" que j'appelle à la fin de mon programme.

Terminapor

I'll see you rise.

Ton destructeur est appelé lorsque ton instance est supprimée, tu dois mal manipuler une instance quelque part alors :??:

---------------
Perhaps you don't deserve to breathe

beuted

Citation :

le destructeur d'un objet créé de façon statique est appelé de façon implicite dès que le programme quitte la portée dans lequel l'objet existe
le destructeur d'un objet créé de façon dynamique doit être appelé grâce au mot clé delete, qui permet de libérer la mémoire occupée par l'objet.

Mon destructeur se déclenchait quand je ne le souhaitais pas apparemment. Je l'ai simplement supprimé et remplacé par une fonction libererTableau.

Message cité 1 fois

Publicité

Xavier_OM

Monarchiste régicide (fr quoi)

beuted a écrit :

Citation :

Mon destructeur se déclenchait quand je ne le souhaitais pas apparemment. Je l'ai simplement supprimé et remplacé par une fonction libererTableau.

Les destructeurs ne se déclenchent pas de manière aléatoire Utilise ton debugger pour mettre un point d'arrêt dans le destructeur et une fois dedans regarde la pile d'appel, pour comprendre d'où ça part. Comme dit Terminapor c'est une erreur de manipulation.

---------------
Il y a autant d'atomes d'oxygène dans une molécule d'eau que d'étoiles dans le système solaire.

FORUM HardWare.fr

Programmation

C++

pointeur de tableau 2D d'entiers...

Sujets relatifs
Fonction qui retourne un tableau dynamique	couleur de cellule tableau automatique fichier odt php
tableau de chaine de caractère : enregistrement	Scrollbar d'un tableau un peu complexe
Remplissage d'un tableau JavaScript	[CPP/Lua] Pointeur sur table
déclarer un pointeur vers un tableau de tableaux ...?	Trie tableau multidimension
A supprimer
Plus de sujets relatifs à : pointeur de tableau 2D d'entiers...

Page générée en 0.079 secondes