Discussion :

[DavLink]

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]

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]

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]

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]

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]

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]

ton pointeur n'est pas initialisé...

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

[InOCamlWeTrust]

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.