Problème de réallocation de mémoire de tableau 2d

**sebaaas** · 21/06/2021, 21h50

Bonjour à tous,

J'ai un petit soucis avec un tableau. J'ai réussi à allouer la mémoire (ouf) mais je pense que mon code est foireux (... en effet, j'ai une erreur de segmentation) lors de la réalloaction:

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
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
 
int main()
{
 
  int i,j=0;
  char ***tableau=NULL;
  int nombre_de_ligne = 4;
  int tableau_nombre_de_colonne[4]={4, 2, 3, 5};
  //allocation
  tableau =  malloc(nombre_de_ligne * sizeof tableau);
 
	for(i=0; i < nombre_de_ligne; i++)
  {
		tableau[i]= malloc(tableau_nombre_de_colonne[i]*sizeof tableau[i]);
    for(j=0; j<tableau_nombre_de_colonne[i];j++)
    {
		  tableau[i][j] = malloc(65 * sizeof *tableau[i][j]);  
    }  
  }
  //reallocation
  nombre_de_ligne = 6;
  int nouveau_tableau_nombre_de_colonne[6]={1,4, 7, 3, 2,9};
 
  tableau =  realloc(tableau,nombre_de_ligne * sizeof tableau);
  for(i =0; i < nombre_de_ligne; i++)
  {
 
    tableau[i]= realloc(tableau[i],tableau_nombre_de_colonne[i]*sizeof tableau[i]);
 
    for(j=0; j<nouveau_tableau_nombre_de_colonne[i];j++)
    {
      tableau[i][j] = realloc(tableau[i][j],65 * sizeof *tableau[i][j]);  
    }
 
  }
 
}

Merci de votre aide

**hurukan** · 22/06/2021, 09h03

Je ne suis pas certain de ce que tu voudrais faire avec ce programme...

Quand je lis cette instruction:

Code :

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

1
2
 
tableau[i][j] = realloc(tableau[i][j],65 * sizeof *tableau[i][j]);

Je suis étonné que le compilateur ne bronche pas... je pensais que sizeof était une macro qui acceptait un paramètre: sizeof(variable), par exemple.
Quand j'exécute ton programme, j'ai en effet une erreur de segmentation à un moment à cette ligne de code.

Il faudrait vérifier si tableau[i][j] contiendrait NULL ou pas... comme realloc() utilise l'ancienne adresse pour lui fournir une "nouvelle taille" à ton tableau, si jamais l'adresse est à NULL (la reallocation n'a pas réussi) tu risques de planter ton application...

**hurukan** · 22/06/2021, 09h07

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
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
 
int main()
{
 
  int i,j=0;
  char ***tableau=NULL;
  int nombre_de_ligne = 4;
  int tableau_nombre_de_colonne[4]={4, 2, 3, 5};
  //allocation
  tableau =  malloc(nombre_de_ligne * sizeof(tableau));
 
	if(tableau==NULL) 
	{
		fprintf(stderr,"Erreur d'allocation de mémoire (1)\n");
		exit(1);
	}
 
	for(i=0; i < nombre_de_ligne; i++)
  {
		tableau[i]= malloc(tableau_nombre_de_colonne[i]*sizeof(tableau[i]));
		if(tableau[i]==NULL) 
		{
			fprintf(stderr,"Erreur d'allocation de mémoire (2)\n");
			exit(2);
		}
    for(j=0; j<tableau_nombre_de_colonne[i];j++)
    {
		  tableau[i][j] = malloc(65 * sizeof (*tableau[i][j]));  
    }  
  }
  //reallocation
  nombre_de_ligne = 6;
  int nouveau_tableau_nombre_de_colonne[6]={1,4, 7, 3, 2,9};
 
	fprintf(stderr,"DEBUG: ICI (1)\n");
 
  tableau =  realloc(tableau,nombre_de_ligne * sizeof(tableau));
	if(tableau==NULL)
	{
		if(tableau==NULL) 
		{
			fprintf(stderr,"Erreur d'allocation de mémoire (3)\n");
			exit(3);
		}
	}
  for(i =0; i < nombre_de_ligne; i++)
  {
		fprintf(stderr,"DEBUG: ICI (2)\n");
    tableau[i]= realloc(tableau[i],tableau_nombre_de_colonne[i]*sizeof(tableau[i]));
		if(tableau[i]==NULL) 
		{
			fprintf(stderr,"Erreur d'allocation de mémoire (3)\n");
			exit(4);
		}
    for(j=0; j<nouveau_tableau_nombre_de_colonne[i];j++)
    {
			fprintf(stderr,"DEBUG: ICI (3)\n");
      tableau[i][j] = realloc(tableau[i][j],65 * sizeof (*tableau[i][j]));  
			if(tableau[i][j]==NULL) 
			{
				fprintf(stderr,"Erreur d'allocation de mémoire (4)\n");
				exit(4);
			}
    }
		fprintf(stderr,"DEBUG: ICI (4)\n");
  }
  fprintf(stderr,"DEBUG: ICI (5)\n");
}

Comme j'ai pas beaucoup dormi cette nuit je n'ai pas la volonté de chercher à comprendre pourquoi tu veux changer la taille de ton tableau.
Voilà ce que j'ai été capable de faire ce matin lol !!

**dalfab** · 22/06/2021, 10h23

Bonjour,

Ça me parait être un exercice particulièrement tordu. C'est très loin d'être simple.
Quand tu fait un realloc(), tu dois passer en paramètre un pointeur qui a été préalablement alloué. En retour tu auras une nouvelle allocation et tes données précédentes transférées dedans.
- Si la taille réallouée est plus petite: Tu perds des données donc ici des pointeurs sur des allocations sont irrémédiablement perdus et tu as une fuite mémoire! Il faut donc utiliser free() à bon escient avant d'appeler realloc()!
- Si la taille réallouée est plus grande: Tu as à la fin de la zone allouée des pointeurs aléatoires! Appeler realloc() sur ces pointeurs aléatoires donneras un plantage. Il faut utiliser malloc() et pas realloc() pour créer ces nouvelles allocations.

Ecrire ce code sur un tableau 2D est complexe, mais ici tu as un tableau 3D, il faut une très bonne connaissance du langage pour ne pas s'y perdre.

Si ta réorganisation de tableau était à nombre total d'objet constant, il faudrait re-répartir les données initiales dans le tableau final. Au moins ça, ça aurait un sens. Et pour résoudre ce problème, il serait par exemple beaucoup plus simple de ne pas utiliser realloc(). On crée un tout nouveau tableau destination avec des malloc(), on transfère toutes les données dans le nouveau tableau, on libère le tableau initial avec des free().

**foetus** · 22/06/2021, 10h33

Envoyé par dalfab

Quand tu fait un realloc(), tu dois passer en paramètre un pointeur qui a été préalablement alloué.

realloc fait aussi malloc si tu lui passes NULL.
realloc, documentation en anglais sur cplusplus.com.

Et ensuite, je n'ai pas envie/ le temps de tester

, mais tu as 1 tableau d'adresses.
Mais comme chaque case contient 1 adresse, tu peux également allouer 1 tableau d'adresses

Donc : void* tableau=NULL; ou 1 truc comme cela

tableau : | A | B | ... | X |

Avec (ici on a des tableaux d'adresses/ de tableaux) :
A pointant vers | A1 | A2 | ... | AX |
B pointant vers | B1 | B2 | ... | BX |
...
X pointant vers | X1 | X2 | ... | XX |

Et (ici on a des tableaux de char donc char* XX) :
A1 pointant vers | A11 | A12 | ... | A1X |
A2 pointant vers | A21 | A22 | ... | A2X |
...
AX pointant vers | AX1 | AX2 | ... | AXX |

**WhiteCrow** · 22/06/2021, 11h29

Bonjour,
ce qui peut également énormément simplifier le code est :

créer une structure de données adaptée ;
créer les primitives d'accès ;

Là on a le choix :

tableau à croissance dynamique ;
liste, éventuellement implémentée sous forme de tableau ;
comme le PO cherche des listes de listes de strings on peut éventuellement se poser la question si un trie, ou toute autre structure arborescente, ne ferait pas l'affaire ;

Mais l'important est surtout de ne pas traîner partout de tonnes de *, de créer une (ou plusieurs) structure de données adaptée et écrire des fonctions.

**Sve@r** · 22/06/2021, 10h26

Envoyé par sebaaas

Bonjour à tous,

Salut

Envoyé par sebaaas

J'ai un petit soucis avec un tableau. J'ai réussi à allouer la mémoire (ouf) mais je pense que mon code est foireux (... en effet, j'ai une erreur de segmentation) lors de la réalloaction:

Déjà ton titre parle de tableau 2D (typiquement un échiquier) mais tes 3 étoiles (et tes 3 allocations imbriquées) sont représentatifs d'un tableau 3D (typiquement un rubik's cube). Or bien conceptualiser ses objets est un impératif.
Ensuite je voudrais faire un parallèle sur tes 3 allocations

tableau = malloc(nombre_de_ligne * sizeof tableau)
tableau[i]= malloc(tableau_nombre_de_colonne[i] * sizeof tableau[i])
tableau[i][j] = malloc(65 * sizeof *tableau[i][j])

Est-ce que tu vois la différence entre la 3° syntaxe (correcte) et les deux précédentes (incorrectes)?

Mis à part ce détail (qui est le caillou qui fait tout planter) ton code me semble correct. Désolé peut pas tester suis pas chez-moi en ce moment (je pourrai vendredi si c'est pas réglé d'ici là).

Sinon tester le malloc c'est bien mais ta solution de tout quitter en vrac n'est pas bonne. Une bonne gestion c'est "un malloc rate alors je nettoie tout ce qui a été alloué et je retourne une valeur spécifique à l'appelant qui gérera ce souci de son côté". De même pour un realloc on ne réalloue jamais le pointeur alloué. D'abord on réalloue sur un pointeur temporaire ce qui permet de ne pas perdre le pointeur originel afin de pouvoir le libérer si la réallocation échoue. Et si la réallocation réussit alors là on recopie le pointeur temporaire dans le pointeur originel. Hé oui, bien gérer une allocation ce n'est pas évident. C'est pour cela qu'on essaye généralement de ne pas dépasser la 2D voire même rester en 1D et convertir ensuite les coordonnées 2D (3D) en 1D (après tout, un rubuk's cube ce ne sont que des petits cubes qu'on peut mettre sur une ligne). Ainsi un seul gros malloc au lieu de plein de petits.

Envoyé par dalfab

- Si la taille réallouée est plus petite: Tu perds des données donc ici des pointeurs sur des allocations sont irrémédiablement perdus

T'es sûr? Il me semble (à prendre au conditionnel car je n'ai plus l'origine de ce souvenir) qu'un realloc plus petit ne fait rien du tout... En tout cas si c'est vrai c'est une très bonne remarque !!!

Envoyé par dalfab

- Si la taille réallouée est plus grande: Tu as à la fin de la zone allouée des pointeurs aléatoires! Appeler realloc() sur ces pointeurs aléatoires donneras un plantage. Il faut utiliser malloc() et pas realloc() pour créer ces nouvelles allocations.

Là aussi très bien vu

Problème de réallocation de mémoire de tableau 2d

C

Vue hybride

Discussions similaires

Partager

Partager