Allocation de pointeur sur tableau dans un struct : erreur incompréhensible

**DavLink** · 18/10/2006, 23h57

Bonjour,

Je viens de commencer le développement d'un petit module en C gérant un carré de chiffres pour un jeu de sudoku. J'utilise donc une structure contenant les différents champs de l'objet, dont un pointeur sur le tableau qui contient les chiffres du carré. Je développe sous Linux avec gcc.

Lors de l'allocation de mémoire pour le tableau, le programme sort sur une erreur que je ne comprends pas. Voici la sortie du shell :

Code :

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

1
2
*** glibc detected *** free(): invalid next size (fast): 0x0804a018 ***
Abandon

Je pense que ce n'est pas le comportement normal de malloc. J'ai mis un traitement d'erreur signalant si le pointeur contient NULL après allocation, il n'est même pas exécuté.

Le plus étrange, c'est quand je ne laisse plus que 2 champs unsigned int (j'en ai 3), ça marche...

Voici les sources :

sudokuregion.c (mon module)

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
// sudokuregion.c
 
// Gère une région de grille de sudoku
// (carré de 9 cases gnéralement)
 
#include <stdio.h>
#include <stdlib.h>
 
#include "sudokuregion.h"
 
struct sudokuRegion {
 
  unsigned int *numarray;
 
  unsigned int width;
  unsigned int height;
 
  unsigned int len;
 
};
 
/*
Le constructeur
*/
 
sudokuRegion sudokuRegion_new() {
 
  // Allocation de la structure
  sudokuRegion sreg = malloc(sizeof(sudokuRegion));
  if(sreg == NULL) {
    fprintf(stderr, "Erreur allocation structure!\n");
    exit(EXIT_FAILURE);
  }
 
  // Remplissage des champs
  sreg->width = 3;
  sreg->height = 3;
  sreg->len = 9;
 
  // Allocation du tableau
  // (et ça plante ici)
  sreg->numarray = calloc(sreg->len, sizeof(int));
  if(sreg->numarray == NULL) {
    fprintf(stderr, "Erreur allocation tableau!\n");
    exit(EXIT_FAILURE);
  }
 
  return sreg;
 
}
 
/*
Le libérateur
*/
 
void sudokuRegion_dispose(sudokuRegion sreg) {
 
  free(sreg);
  sreg = NULL;
 
}

... et son header sudokuregion.h

Code :

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

1
2
3
4
5
6
7
8
9
#ifndef SUDOKUREGION_H
#define SUDOKUREGION_H
 
typedef struct sudokuRegion * sudokuRegion;
 
extern sudokuRegion sudokuRegion_new();
extern void sudokuRegion_dispose(sudokuRegion reg);
 
#endif

N'oublions pas le programme de test : sudoku.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <stdlib.h>
 
#include "sudokuregion.h"
 
int main(int argc, char *argv[]) {
 
  sudokuRegion region = sudokuRegion_new();
  sudokuRegion_dispose(region);
 
  return EXIT_SUCCESS;
}

...ainsi que le Makefile au cas où!

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
CC=gcc
CFLAGS=-g -Wall -std=c99
LDFLAGS=-g -Wall -std=c99
EXEC=sudoku
 
all: $(EXEC)
 
sudoku: sudoku.o sudokuregion.o
	$(CC) -o $@ $^ $(LDFLAGS)
 
%.o: %.c
	$(CC) -o $@ -c $< $(CFLAGS)
 
clean:
	rm -rf *.o
 
mrproper: clean
	rm -rf $(EXEC)

J'ai essayé plein de trucs, même le changement de l'ordre des champs dans le struct y est pour quelque chose!

Quelles sont les erreurs que j'ai faites dans mon code? Que dois-je corriger pour que ça veuille bien marcher?

Merci d'avance.

**Corentor** · 19/10/2006, 01h29

Bonjour,

je n'ai pas regardé votre code en détail mais il y a quelque chose qui me semble suspect :

Vous définissez :

Code :

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

1
2
 
typedef struct sudokuRegion * sudokuRegion;

et vous allouez :

Code :

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

1
2
sudokuRegion sreg = malloc(sizeof(sudokuRegion));

**Médinoc** · 19/10/2006, 09h12

Code :

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

typedef struct sudokuRegion * sudokuRegion;

Résultat, c'est bien l'erreur signalée par Corentor : Tu alloues la taille d'un pointeur...

Code :

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

sudokuRegion sreg = malloc(sizeof(sudokuRegion));

Correction:

Code :

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

typedef struct sudokuRegion SUDOKUREGION, *PSUDOKUREGION;

Code :

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

1
2
3
PSUDOKUREGION pSreg = malloc(sizeof(SUDOKUREGION));
/* ou bien */
PSUDOKUREGION pSreg = malloc(sizeof(*pSreg));

**Emmanuel Delahaye** · 19/10/2006, 10h29

Envoyé par DavLink

Lors de l'allocation de mémoire pour le tableau, le programme sort sur une erreur que je ne comprends pas. Voici la sortie du shell :

Code :

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

1
2
*** glibc detected *** free(): invalid next size (fast): 0x0804a018 ***
Abandon

J'ai mis en route mon traqueur de mémoire, et je trouve ceci :

SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D24E8 (36 bytes) calloc'ed at line 44 of 'sudokuregion.c' not freed

C'est assez clair, non ?

Ceci fonctionne :

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
#include "ed/inc/sysalloc.h" 
// ----------------------------------------------------------------------------
// sudokuregion.c
 
// Gère une région de grille de sudoku
// (carré de 9 cases gnéralement)
 
#include "sudokuregion.h"
 
#include <stdio.h>
#include <stdlib.h>
 
struct sudokuRegion
{
   unsigned int *numarray;
 
   size_t width;
   size_t height;
 
   size_t len;
};
 
/*
Le constructeur
*/
 
sudokuRegion sudokuRegion_new (void)
{
 
   // Allocation de la structure
   sudokuRegion sreg = malloc (sizeof * sreg);
   if (sreg == NULL)
   {
      fprintf (stderr, "Erreur allocation structure!\n");
      exit (EXIT_FAILURE);
   }
 
   // Remplissage des champs
   sreg->width = 3;
   sreg->height = 3;
   sreg->len = 9;
 
   // Allocation du tableau
   // (et ça plante ici)
   sreg->numarray = malloc (sreg->len * sizeof * sreg->numarray);
   if (sreg->numarray == NULL)
   {
      fprintf (stderr, "Erreur allocation tableau!\n");
      exit (EXIT_FAILURE);
   }
 
   return sreg;
}
 
/*
Le libérateur
*/
 
void sudokuRegion_dispose (sudokuRegion sreg)
{
   if (sreg != NULL)
   {
      free(sreg->numarray), sreg->numarray = NULL;
   }
   free (sreg), sreg = NULL;
}

J'ai corrigé l'allocation de la structure dans le constructeur en utilisant les méthodes recommandées par les professionels (utiliser l'objet plutôt que le type). En effet, le type étant un pointeur, j'ai bien peur sa taille ne soit trop petite, ce qui évidemment provoque un comportement indéfini quand on écrit dans la structure...

Je déconseille de construire des types pointeurs, c'est illisible. En C, on a pas honte de montrer ses pointeurs. Au contraire... On les arbore fièrement (d'ailleurs je vais me faire faire un T-shirt

I'm a C programmer
I like pointers

char *p;

**DavLink** · 19/10/2006, 15h10

Effectivement, c'était une erreur toute bête... j'allouais la taille d'un pointeur donc ça débordait, plantage inévitable!

Merci beaucoup pour votre aide, tout de même.

**Médinoc** · 19/10/2006, 15h18

Enfin ici, c'était même pire que seulement "cacher le pointeur" : Le type pointeur avait le même nom que la structure elle-même (ce qui ne serait pas passé en C++), ce qui a mené à la confusion au niveau du type...

PS: Emmanuel, ton pointeur n'est pas initialisé...

**Emmanuel Delahaye** · 19/10/2006, 18h35

Envoyé par Médinoc

ton pointeur n'est pas initialisé...

OK :
char *p = NULL;
des fois que ça se coince dans la machine à laver...

**InOCamlWeTrust** · 19/10/2006, 23h11

Ben tu vois, moi je suis surtout pour une abstraction quasi-totale, possible en C, si on se donne la peine de construire les structures de données adéquates, entre autres avec des typedef et les règles qui vont bien. Ca permet de mieux se concentrer sur les algorithmes. Dans le cas contraire, l'utilisation de pointeurs (qui en soi n'a rien de difficile) peut en dérouter beaucoup au début, et j'ai bien peur que cette chère citation, bien connue dans le monde fonctionnel (mais je continue de penser que le C a beaucoup d'aspects des langages fonctionnels), soit vraie à l'égard de ceux qui ont du mal avec les pointeurs et autres particularités du C.

Haskell, OCaml, Lisp, Clean, Miranda, SML, Scheme...

Everything else is Dysfunctionnal programming.

**Emmanuel Delahaye** · 19/10/2006, 23h44

Envoyé par InOCamlWeTrust

Ben tu vois, moi je suis surtout pour une abstraction quasi-totale,

On a vu ce que ça donnait...

**InOCamlWeTrust** · 20/10/2006, 09h48

En C, plus qu'ailleurs, il faut prendre des précautions évidentes : ça ne veut pas dire qu'"abstraire" signifie "ne pas réfléchir"... ça veut juste dire prendre un tout petit peu de hauteur.

La personne qui sait utiliser malloc sera évidemment au fait qu'étant donné que la fonction retourne l'adresse d'une zone mémoire, cette adresse ne peut pas être contenue dans une variable du type du sizeof, à moins que les types soient compatibles, auquel cas, c'est sûr, il y a danger.

Par exemple, pourquoi ce genre de code ne conviendrait-il pas :

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
 
typedef char *string_t;
 
void print_string(string_t s);
 
/* du code... */
 
string_t s;
 
/* et pourquoi ne pas faire une fonction de création et de destruction de chaines de caracteres ? */
 
s = malloc(N * sizeof(char));
 
print_string(s);
 
/* etc... */

**Emmanuel Delahaye** · 20/10/2006, 11h09

Envoyé par InOCamlWeTrust

En C, plus qu'ailleurs, il faut prendre des précautions évidentes : ça ne veut pas dire qu'"abstraire" signifie "ne pas réfléchir"... ça veut juste dire prendre un tout petit peu de hauteur.

Vi vi...

http://emmanuel-delahaye.developpez.com/tad.htm

Par exemple, pourquoi ce genre de code ne conviendrait-il pas :

Parce qu'il n'y a pas de lien visible entre le type abstrait et le type réel.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef char *string_t;
 
void print_string(string_t s);
 
/* du code... */
 
string_t s;
 
/* et pourquoi ne pas faire une fonction de création et de destruction de chaines de caracteres ? */
 
s = malloc(N * sizeof(char));

On ne sait pas comment appeler malloc(). Tu as mis sizeof (char), pourquoi ?

Et si le type caché de string_t passe en wchar_t * ?

Je fais comme ça :

http://emmanuel-delahaye.developpez.com/clib.htm
Module FSTR

**InOCamlWeTrust** · 20/10/2006, 13h19

Dans cet exemple j'ai mis un appel à malloc, mais le plus propre est ce que je mets en remarque dans les commentaires : faire une fonction (voire une macro, mais je ne suis pas fan des macro paramètrées) d'allocation d'objets de type string_t, ainsi plus de problèmes.

Je sais, c'est pas ce que l'on fait courament en C, et moi-même dans mes programmes je ne procède pas ainsi, mais pour débuter proprement et sans faire des choses "dangereuses" sans le savoir, je pense que ça peut être intéressant de montrer cette vision des choses.

Mais je suis d'accord, tout programmeur à sa référence, ou sa religion (c'est d'ailleurs très bien expliqué sur le Wiki de Haskell...) en matière de programmation, et tout porte à croire que si il sait bien maîtriser les techniques qu'il apprécie, tout ira pour le mieux. Mais lorsque l'on débute, le manque de références peut s'avérer déroutant.

Allocation de pointeur sur tableau dans un struct : erreur incompréhensible

C

Discussions similaires

Partager

Partager