Discussion :

[mdabire]

Salut,
Je voudrais savoir comment declarer un tableau dynamique dont les cases se suivent en memoire.

en faisant: int *a = malloc(10*sizeof(int));
que ce soit pareil que: int a[10];
en mémoire.

Merci à tous.

[coyotte507]

Salut,

tu viens toi-même de répondre à ta question

[Thierry Chappuis]

Salut,
Je voudrais savoir comment declarer un tableau dynamique dont les cases se suivent en memoire.

en faisant: int *a = malloc(10*sizeof(int));
que ce soit pareil que: int a[10];
en mémoire.

Merci à tous.

malloc() alloue une zone mémoire contigüe. Je ne vois donc pas le problème.

Thierry

[Emmanuel Delahaye]

Je voudrais savoir comment declarer un tableau dynamique dont les cases se suivent en memoire.

en faisant: int *a = malloc(10*sizeof(int));
que ce soit pareil que: int a[10];
en mémoire.

Le tableau créé par l'allocation dynamique est conforme, c'est à dire que ses éléments sont consécutifs en mémoire (heureusement, sinon, à quoi servirait malloc()...). C'est garanti par la norme qui définit le langage C.

Une fois créé, l'usage est strictement identique à celui d'un tableau de taille fixe.

Attention, le tableau ainsi crée n'est ni initialisé, ni contrôlé en taille. Tout débordement entraine un comportement indéterminé.

[Sve@r]

Salut,
Je voudrais savoir comment declarer un tableau dynamique dont les cases se suivent en memoire.

en faisant: int *a = malloc(10*sizeof(int));
que ce soit pareil que: int a[10];
en mémoire.

Merci à tous.

N'oublie pas que si tu fais du malloc() faudra penser ensuite au free() quand tu n'auras plus besoin de la zone allouée...

[mdabire]

Désolé, je pensais résoudre mon problème, mais je me suis planté apparemment;

j'ai refait un programme pour tester la continuité en mémoire, ça marche pour l'allocation d'un tableau à une dimension, mais pour 2 dimensions il ne marche plus vraiment; dans mon cas: dans le tableau int cases[8][8], les cases[0][7] et cases[1][0] ne sont pas continue en mémoire. comment faire pour qu'ils soient continue ?

Voilà mon programme:

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
int largeur = 8, hauteur = 8;
int **cases;
int **cases_couleur;
 
void init_cases_taille()
{
	int i;
 
	cases = malloc(largeur * sizeof(int));
	cases_couleur = malloc(largeur * sizeof(int));
 
	for(i=0; i<hauteur; i++)
	{
		cases[i] = malloc(hauteur * sizeof(int));
		cases_couleur[i] = malloc(hauteur * sizeof(int));
	}
}
 
int main()
{
	init_cases_taille();
 
	int i, j;
 
	for(i = 0; i<8; i++)
	{
		for(j = 0; j<8; j++)
		{
			printf("&cases[%d][%d] = %d\n", i, j, &cases[i][j]);
		}
		printf("\n");
	}
}

Merci beaucoup pour l'aide.

[contremaitre]

tu peux faire un malloc de taille * largeur * hauteur
Et pour acceder à la case [i][j] il faut faire tableau[ j * largeur + i ]

[Melem]

tu peux faire un malloc de taille largeur * hauteur
Et pour acceder à la case [i][j] il faut faire tableau[ j * largeur + i ]

malloc de largeur * hauteur * la taille d'un élément

[Médinoc]

Pour l'allocation d'un tableau à deux dimensions contigu qui puisse être utilisé avec la syntaxe tab[x][y], voir ce code, qui fait une allocation par dimension:
http://www.developpez.net/forums/sho...70&postcount=7

[Sve@r]

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
int largeur = 8, hauteur = 8;
int **cases;
int **cases_couleur;
 
void init_cases_taille()
{
	int i;
 
	cases = malloc(largeur * sizeof(int));
	cases_couleur = malloc(largeur * sizeof(int));
 
	for(i=0; i<hauteur; i++)    // A mon avis, tu aurais dû écrire for(i=0; i < largeur; i++)
	{
		cases[i] = malloc(hauteur * sizeof(int));
		cases_couleur[i] = malloc(hauteur * sizeof(int));
	}
}

j'ai refait un programme pour tester la continuité en mémoire, ça marche pour l'allocation d'un tableau à une dimension, mais pour 2 dimensions il ne marche plus vraiment; dans mon cas: dans le tableau int cases[8][8], les cases[0][7] et cases[1][0] ne sont pas continue en mémoire.

C'est normal (j'ai replacé ton code en haut pour qu'on le revoit mieux)
A chaque tour de boucles for() (tu t'es d'ailleurs trompé de valeur dans le for), tu réserves "n" cases entières. Mais chaque allocation est, du point de vue µc, différente de la précédente et de la suivante. C'est comme si t'avais

Code :

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

1
2
3
int *a=malloc(5 * sizeof (int));
int *b=malloc(5 * sizeof (int));
int *c=malloc(5 * sizeof (int));

Chaque allocation te donnera 5 int continus mais les groupes ne seront pas forcément l'un à la suite de l'autre. Le host te donne la mémoire là où il peut la prendre (et il cherche aussi à optimiser pour éviter de créer un gruyère).

Donc comme les autres l'ont dit, si tu veux "n" int de façon continue, te faut allouer ces "n" int avec un seul malloc puis calculer la position (x,y) en fonction de i et de la largeur du plateau théorique.

[amaury_dlv]

malloc() alloue une zone mémoire contigüe. Je ne vois donc pas le problème.

Thierry

En C99 et C90 oui mais je me demande si ça a toujours été le cas. Il me semble que ce n'était pas toujours garantie avant la norme ANSI (mais je peux tout à fait me tromper). N'ayant pas la première édition de K&R sous la main je n'ai pas pu le vérifier.

[ram-0000]

malloc() alloue une zone mémoire contigüe. Je ne vois donc pas le problème.

En C99 et C90 oui mais je me demande si ça a toujours été le cas.

Je ne voie pas bien comment la mémoire n'aurait pas pu être contigüe même avant.

Ou alors cela veut dire que malloc aurait pu retourner plusieurs pointeurs sur les différentes zones allouées et que la somme des zones allouées aurait fait la taille demandée. En tant que développeur, je n'aurais pas aimé écrire la fonction malloc() alors

[Emmanuel Delahaye]

En C99 et C90 oui mais je me demande si ça a toujours été le cas.

Oui.

[orfix]

Désolé, je pensais résoudre mon problème, mais je me suis planté apparemment;

j'ai refait un programme pour tester la continuité en mémoire, ça marche pour l'allocation d'un tableau à une dimension, mais pour 2 dimensions il ne marche plus vraiment; dans mon cas: dans le tableau int cases[8][8], les cases[0][7] et cases[1][0] ne sont pas continue en mémoire. comment faire pour qu'ils soient continue ?

Voilà mon programme:

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
int largeur = 8, hauteur = 8;
int **cases;
int **cases_couleur;
 
void init_cases_taille()
{
	int i;
 
	cases = malloc(largeur * sizeof(int));
	cases_couleur = malloc(largeur * sizeof(int));
 
	for(i=0; i<hauteur; i++)
	{
		cases[i] = malloc(hauteur * sizeof(int));
		cases_couleur[i] = malloc(hauteur * sizeof(int));
	}
}
 
int main()
{
	init_cases_taille();
 
	int i, j;
 
	for(i = 0; i<8; i++)
	{
		for(j = 0; j<8; j++)
		{
			printf("&cases[%d][%d] = %d\n", i, j, &cases[i][j]);
		}
		printf("\n");
	}
}

Merci beaucoup pour l'aide.

• main retourne un int
• les mallocs peuvent échouer donc toujours tester leurs retours
• les premières allocations doivent allouer des tableaux de pointeurs vers int :
  
  

  Code :

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

  1
  2
  3
  	cases = malloc(largeur * sizeof(int*));
  	cases_couleur = malloc(largeur * sizeof(int*));

• tu te mélange un peu les pinceaux avec ces variables largeur hauteur...si je suis ton raisonnement il faut faire :
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  void init_cases_taille()
  {
  <...>
  	for(i=0; i<largeur; i++)
  <...>
  }

  biensûr cela ne change rien ici puisque largeur==hauteur==8