ces temps-ci, je fais de l'openGL, et en ce moment, je fais de la génération de terrains

http://www.enregistrersous.com/images2/14273484920080324160707.png

mais j'ai un tas de difficultés à manipuler les tableaux de float, dont chaque float symbolise la hauteur d'un point du terrain

en fait, je dois faire des fonctions qui retournent des tableaux de float à double entrée, d'autres qui en prennent en paramètre, etc... auriez vous des conseils à me donner

heu, je n'ai pas de conseil mais si tu nous présente un bout de code qui pose probleme, on pourra toujours regarder.

float[][] gateau(int longueur, int largeur){
.......srand(time(NULL));
.......float terrain[longueur][largeur]
.......int compteur=0;
.......int compteur2=0;
.......while(compteur<longueur){
..............while(compteur2<largeur){

.....................terrain[compteur][compteur2]=
rand()%1;
.....................compteur2=compteur2+1;
..............}
..............compteur2=0;
..............compteur=compteur+1;
.......}
.......return terrain;
}

celui-là par exemple ne marche pas, il fait une erreur a la compilation (error: expected unqualified-id before ‘[’ token)

il y a deux méthodes pour gérer ce genre de choses.

première méthode : utiliser un tableau 2D :

int main(...)
{
float terrain1[10][20]; // de taille connue à l'avance
float** terrain2; // de taille connue à l'exécution.
terrain2 = alloc_terrain(10,20);
affiche(terrain1,10,20);
affiche(terrain2,10,20);
detruit(terrain2,10);
}

float** alloc_terrain(int x, int y)
{
float** terrain = (float**)malloc(sizeof(float*)*x);
for (int i = 0; i < x; i++)
terrain[i] = (float*)malloc(sizeof(float)*y);
return terrain;
}

void affiche(float** terrain, int x, int y)
{
for (int i = 0; i < x; i++)
for (int j = 0; j < y; j++)
affiche_case(terrain[i][j]);
}

void detruit(float** terrain, int x)
{
for (int i = 0; i < x; i++)
free(terrain[i]);
free(terrain);
}

Voila tu a un exemple de création et de destruction pour ces tableaux plus des fonctions qui les reçoivent ou les retourne.

L'autre possibilité est d'utiliser des tableaux à une seule dimensions. C'est parfois préféré car ça peut-être plus performant (sans aucune garantie).

int main(...)
{
float terrain1[10*20]; // de taille connue à l'avance
float* terrain2; // de taille connue à l'exécution.
terrain2 = alloc_terrain(10,20);
affiche(terrain1,10,20);
affiche(terrain2,10,20);
detruit(terrain2);
}

float* alloc_terrain(int x, int y)
{
float* terrain = (float*)malloc(sizeof(float)*x*y);
return terrain;
}

void affiche(float* terrain, int x, int y)
{
for (int i = 0; i < x; i++)
for (int j = 0; j < y; j++)
affiche_case(terrain[i*x+j]);
}

void detruit(float* terrain)
{
free(terrain);
}

les tableaux se déclarent avec des '*' et non pas avec des '[]' usuellement sauf dans quelques cas particuliers (utiles surtout pour les chaînes de caractères).

d'autre part, dans ta fonction gateau, tu déclares ton terrain d'une manière statique :

float terrain[x][y];

Mais en lui passant comme dimension des paramètre de la fonction. Certain compilo pourrait accepter ça, mais ce n'est pas bon car ce n'est pas dans la norme du langage. Il faut dans ce cas là construire dynamiquement ton tableau avec des malloc.

Et enfin, si par hasard tu connais la dimension de ton tableau à la compilation, tu ne peut tout de même pas renvoyer à la fin d'une fonction un pointeur vers un objet alloué statiquement dans la fonction (par exemple si tu avait mis terrain[10][20]; dans ta fonction gateau) car cet objet est alloué dans la pile et n'existe plus à la fin de la fonction. Donc pour renvoyer un pointeur il faut que tu alloue dynamiquement le tableau (ou que tu le déclare avec le mot clef static, mais c'est une autre histoire).

merci dnob700

je me souviens avoir tenté les malloc, et je faisais
tableau=(float**)malloc(longueur*largeur*sizeof(fl
oat))... ca marchait pas

alors qu'en fait, il faut allouer la première dimention, et chacune des entités de la seconde dimention, une par une... je ne savais pas qu'on pouvait faire ca

je devrais faire une structure terrain, pour stocker en même temps le tableau de float a double entrée, la longueur, et la largeur... mais rappelle moi, les structures doivent être construites par un new

non non, si tu fait une structe. Tu peut allouer statiquement la structure genre :

struct terrain
{
float** map;
int x,y;
};

et dans la fonction alloc tu fait :
terrain alloc(int x, int y)
{
terrain t;
t.x = x;
t.y = y;
t.map = (float**)malloc(sizeof(float*)*x);
// la boucle sur x pour l'autre dimension
return t;
}

Là, il n'y a pas de problème. Ton objet terrain est copié dans l'instruction return de la fonction, mais il ne s'agit que de 3 entiers donc c'est très petit.