Erreur de segmentation lor de la redimension d'un tableau

**anate_far_** · 28/12/2021, 13h41

Bonjour je suis actuellement de développer un module de gestion de tableau de chaîne de caractère, j’essaie de faire en sorte qu'il soit redimensionnable mais j'ai une erreur de mémoire et je ne vois pas d'où elle peu venir se qui me pose problème pour la régler pouvez vous m'aidez svp

strarray.c (module de gestion de tableau de chaîne)

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
#include <stdio.h>
#include <stdlib.h>
 
#include "tools.h"
#include "strarray.h"
#include "chararray.h"
 
//constructeur
strarray strarray_create(int len)
{
	strarray tab = tools_malloc(sizeof(struct _strarray));
	tab->len = len;
	tab->alloc = len;
 
	tab->data = tools_malloc(sizeof(chararray) * len);
	for(int i = 0; i < len; i++)
		tab->data[i] = str_to_chararray("void");
 
	return tab;		
}
 
//destructeur
void strarray_destroy(strarray tab)
{
	for(int i = 0; i < tab->alloc; i ++)
		chararray_destroy(tab->data[i]);
	tools_free(tab->data, sizeof(chararray) * tab->alloc);
	tools_free(tab, sizeof(struct _strarray));
}
 
//tools
void strarray_debug(strarray tab)
{
	for(int i = 0; i < tab->len; i ++)
	{
		chararray_debug(tab->data[i]);
		fprintf(stderr, "\n");
	}
}
 
void strarray_resize(strarray tab, int new_alloc)
{
	int i;
 
	chararray* new_data = tools_malloc(sizeof(chararray) * new_alloc);
	for(i = 0; i < tab->len; i ++)
		new_data[i] = str_to_chararray("BOOOOOOO");
 
	tools_free(tab->data, sizeof(chararray) * tab->alloc);
 
	tab->data = new_data;
	tab->alloc = new_alloc;
}
 
 
void strarray_add(strarray tab, char* str);
 
void strarray_add_to_index(strarray tab, int index, char* str)
{
	if((tab->alloc <= 0) || index < 0)
	{
		fprintf(stderr, "ERROR <strarray_add> : tableau trop petit\n");
		return; 
	}
 
	if(index < tab->len)
	{
		chararray_set_str(tab->data[index],str);
	       return;	
	}
 
	if(index >= tab->alloc )
	{
		strarray_resize(tab, (index + 2) * 2);	
	}
 
	for(int i = tab->len; i < index; i ++)
		tab->data[i] = str_to_chararray("void");
 
	chararray_set_str(tab->data[index], str);
 
	if(tab->len <= index)
		tab->len = index +1;
 
}

chararray.c (module de gestion de chaîne)

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
#include <stdio.h>
#include <stdlib.h>
 
#include "tools.h"
#include "chararray.h"
 
 
//constructeur
chararray chararray_create(int len)
{
	chararray tab = tools_malloc(sizeof(struct _chararray));	
 
	tab->len = len;
	tab->alloc = len;
 
	tab->data = tools_malloc(sizeof(char) *len);
 
	for(int i = 0; i < len; i++)
	{
		tab->data[i] = 'F';
	}
 
	return tab; 
}	
 
chararray str_to_chararray(char* str)
{
	chararray tab = tools_malloc(sizeof(struct _chararray));
	tab->len = size_str(str);
	tab->alloc = size_str(str);
 
	tab->data = tools_malloc(sizeof(char) * tab->alloc);
	for(int i = 0; i < tab->alloc; i ++)
	{
		tab->data[i] = str[i];
	}
 
	return tab;
}
 
char* chararray_to_str(chararray tab)
{
	char* str = tools_malloc(sizeof(char) * tab->len);
 
	for(int i = 0; i < tab->len; i++)
		str[i] = tab->data[i];
 
	return str; 
}
 
//destructeur
void chararray_destroy(chararray tab)
{
	tools_free(tab->data, sizeof(char) * tab->alloc);
	tools_free(tab, sizeof(struct _chararray));
}
 
void str_destroy(char* str)
{
	tools_free(str, sizeof(char) * size_str(str));
}
 
 
//modulation de la taille 
void chararray_resize(chararray tab, int new_alloc)
{
	char* new_data = tools_malloc(sizeof(char) * new_alloc);
 
	for(int i = 0; i < tab->len; i ++)
		new_data[i] = tab->data[i];
	tools_free(tab->data, sizeof(char) * tab->alloc);
 
	tab->data = new_data;
	tab->alloc = new_alloc; 
}
 
void chararray_set_add(chararray tab, int index, char value)
{
	if(tab->alloc <= 0)
	{
		fprintf(stderr, "ERROR <chararray_set_add> : Impossible d'ajouter un element alloc : %c\n", tab->alloc);
		return;
	}
 
	if(index < tab->len)
	{
		tab->data[index] = value;
		tab->len ++;
		return;
	}
 
	if(index >= tab->alloc)
	{
		chararray_resize(tab, (index + 2) * 2); 
	}
 
	for(int i = tab->len; i < index; i ++)
		tab->data[i] = 'F';
       tab->data[index] = value; 	
       if(tab->len <= index)
     		 tab->len = index +1;
 
 
}
 
void chararray_set_str(chararray tab, char* str)
{
	int i;
       for (i = 0; i < size_str(str); i ++)
       {
		chararray_set_add(tab, i, str[i]);
       }	       
}
 
//tools
void chararray_debug(chararray tab)
{
	for(int i = 0; i < tab->len; i++)
	{
		fprintf(stderr, "%c", tab->data[i]);
	}
	fprintf(stderr, "\n");
}

tools.c

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
 
#include <stdio.h>
#include <stdlib.h>
 
#include "tools.h"
 
void tools_memory_init(void)
{
	GLOBAL_MEMORY = 0; 
}
 
void* tools_malloc(int alloc)
{
	void* ptr = malloc(alloc); 
	GLOBAL_MEMORY += alloc;
	return ptr;  
}
 
void tools_free(void* ptr, int alloc)
{
	free(ptr);
	GLOBAL_MEMORY -= alloc; 
}
 
void tools_check_at_end_of_app(void)
{
	if(GLOBAL_MEMORY != 0)
		fprintf(stderr, "Il y a une fuite de memoire de %d octe\n", GLOBAL_MEMORY); 
}
 
 
 
int string_to_int(char* str)
{
	int result = 0, i;
 
	for(i = 0; str[i] != '\0'; i ++)
	{
		result *= 10; 
		result += str[i] - 48;
 
 
	}	
 
	return result; 
}
 
 
int size_str(char* str)
{
	int result = 0;
 
	for(int i = 0; str[i] != '\0'; i ++)
		result ++;
 
	return result; 
}

test.c

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
 
#include <stdio.h>
#include <stdlib.h>
//#include <SDL.h>
//#include <SDL_image.h>
 
//#include "map.h"
#include "tools.h"
#include "chararray.h"
#include "strarray.h"
 
int main(void)
{
	tools_memory_init();
 
	strarray tab = strarray_create(5);
 
	strarray_add_to_index(tab, 8, "anatole");
 
	strarray_debug(tab);
 
	strarray_destroy(tab);
 
	tools_check_at_end_of_app();
	return EXIT_SUCCESS;
}

**gerald3d** · 28/12/2021, 14h23

Bonjour.

Avant d'essayer de trouver la solution au problème voila quelques remarques.

J'ai créé tous les fichiers nécessaires à la compilation de ton projet. Il m'a donc fallu retrouver les structures _strarray et _chararray. Tu commets une première erreur d'écriture. Tu caches les pointeurs dans des définitions. C'est mal

. Ici tu n'as que quelques lignes de code et c'est déjà difficile à lire pour nous à cause de ce masquage.
Tes structures sont déclarées ainsi :

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
struct _chararray {
  int len;
  int alloc;
  char *data;
};
 
typedef struct _chararray* chararray;
 
struct _strarray {
  int len;
  int alloc;
  chararray data;
};
 
typedef struct _strarray* strarray;

BEURK !

Donc première chose à faire, ne cache pas les pointeurs. Le code pourrait devenir alors :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef struct {
  int len;
  int alloc;
  char *data;
} chararray;
 
typedef struct {
  int len;
  int alloc;
  chararay data;
} strarray;

Le code est plus léger et plus clair. Bien sûr cette écriture va générer tout un tas de warnings lors de la compilation puisqu'il faudra maintenant ajouter l'étoile à toute déclaration de pointeur.

Deuxième remarque.
Les fichiers sont soit des fichiers d'entête soit des fichiers sources. Dans les fichiers d'entête on ne trouve que les déclarations de type (tes structures par exemple) et les prototypes des fonctions. Comme ces fichiers vont être inclus dans des fichiers sources on va conditionner leur insertion à une seule fois sinon le compilateur va encore hurler

. Pour se faire on va utiliser #ifndef, #define et #endif. Voila les trois fichiers d'entête modifiés :

tools.h

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
#include <stdio.h>
#include <stdlib.h>
 
#ifndef __TOOLS__
#define __TOOLS__
 
int GLOBAL_MEMORY;
 
void tools_memory_init(void);
void* tools_malloc(int alloc);
void tools_free(void* ptr, int alloc);
void tools_check_at_end_of_app(void);
int string_to_int(char* str);
int size_str(char* str);
#endif

chararray.h

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
#ifndef __CHARARRAY__
#define __CHARARRAY__
 
#include "tools.h"
 
struct _chararray {
  int len;
  int alloc;
  char *data;
};
 
typedef struct _chararray* chararray;
 
//constructeur
chararray chararray_create(int len);
 
chararray str_to_chararray(char* str);
char* chararray_to_str(chararray tab);
 
//destructeur
void chararray_destroy(chararray tab);
 
void str_destroy(char* str);
 
//modulation de la taille
void chararray_resize(chararray tab, int new_alloc);
 
void chararray_set_add(chararray tab, int index, char value);
void chararray_set_str(chararray tab, char* str);
 
//tools
void chararray_debug(chararray tab);
 
#endif

strarray.h

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
#ifndef __STRARRAY__
#define __STRARRAY__
 
#include "chararray.h"
 
struct _strarray {
  int len;
  int alloc;
  chararray data;
};
 
typedef struct _strarray* strarray;
 
//constructeur
strarray strarray_create(int len);
 
//destructeur
void strarray_destroy(strarray tab);
 
//tools
void strarray_debug(strarray tab);
 
void strarray_resize(strarray tab, int new_alloc);
void strarray_add(strarray tab, char* str);
void strarray_add_to_index(strarray tab, int index, char* str);
#endif

Pour finir cette introduction les variables globales sont tant que faire ce peut à bannir. GLOBAL_MEMORY doit être incluse aux outils de gestion mémoire. Il te faut donc aussi une structure pour gérer la mémoire.

**anate_far_** · 28/12/2021, 14h36

houla oui g oublier de mettre les .h dans mon poste mais je ne comprend pas se que tu entend par pointeur caché enfin je n 'utilise pas de variable globale a part dans le module tools pour pouvoir vérifier si il y a des fuites de mémoire

strarray.h

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
 
#ifndef STRARRAY_H
#define STRARRAY_H
 
#define SIZE_ADD_ALLOC 2
 
#include "chararray.h"
 
typedef struct _strarray* strarray;
struct _strarray{
	chararray* data;
	int len;// nb ellement
	int alloc; // taille en mémoire
};
 
//constructeur
strarray strarray_create(int len);
 
//destructeur
void strarray_destroy(strarray tab);
 
//tools
void strarray_debug(strarray tab);
 
void strarray_resize(strarray tab, int new_alloc);
void strarray_add(strarray tab, char* str);
void strarray_add_to_index(strarray tab, int index, char* str); 
 
#endif

chararray.h

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
 
#ifndef CHARARRAY_H
#define CHARARRAY_H
 
typedef struct _chararray* chararray;
 
struct _chararray{
	char* data;
	int len;
	int alloc;
};
 
//constructeur
chararray chararray_create(int len);
chararray str_to_chararray(char* str);
char* chararray_to_str(chararray tab);
//destructeur
void chararray_destroy(chararray tab);
void str_destroy(char* str);
 
//Modulation de la taille
void chararray_resize(chararray tab, int new_alloc);
void chararray_set_add(chararray tab, int index, char value);
void chararray_set_str(chararray tab, char* str);
 
//tools
void chararray_debug(chararray tab);
 
 
#endif

tools.h

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
 
#ifndef TOOLS_H
#define TOOLS_H
 
int GLOBAL_MEMORY;  
 
void tools_memory_init(void);
void *tools_malloc(int alloc); 
void tools_free(void* ptr, int alloc); 
void tools_check_at_end_of_app(void); 
 
 
 
int string_to_int(char* str);
 
int size_str(char* str);
 
#endif

**gerald3d** · 28/12/2021, 14h54

Ceci est un pointeur caché : typedef struct _strarray* strarray;
Le fait décrire strarray str; ne me dis pas ci c'est une variable ou un pointeur. Toi tu le sais parce que c'est toi qui a écrit le code. Mais moi, utilisateur de tes outils je vais m'arracher les cheveux à comprendre pourquoi le compilateur hurle à chaque fois que je l'utilise.

Prenons un exemple simple que tu utilises d'ailleurs. Les concepteurs des types simples non pas créés typedef _char* char;. Tu peux à loisir déclarer une variable char a; ou un pointeur char *a;. Et bien il faut que chararray et strarray soient du même tonneau.

**gerald3d** · 28/12/2021, 17h32

Histoire de t’aiguiller un peu j'ai lancé gdb avec ton programme. Voila sa sortie :

Code :

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

1
2
program received signal SIGSEGV, Segmentation fault.
0x000055555555544a in chararray_set_add ()

Essaie d'utiliser un débogueur tel que gdb. Il te donnera quelques pistes de départ sans trop lui en demander.

Une autre remarque. Prenons par exemple la fonction suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
strarray strarray_create(int len)
{
	strarray tab = tools_malloc(sizeof(struct _strarray));
	tab->len = len;
	tab->alloc = len;
 
	tab->data = tools_malloc(sizeof(chararray) * len);
	for(int i = 0; i < len; i++)
		tab->data[i] = str_to_chararray("void");
 
	return tab;
}

Que se passe-t-il si je passe -1 à cette fonction ? Ou bien un nombre gigantesque ? Est-ce que tools_malloc(); gère le problème ? Et si oui on a quoi en retour ? que vaudra tab dans ces cas là ?

Regardons tools_malloc (); :

Code :

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

1
2
3
4
5
6
void* tools_malloc(int alloc)
{
	void* ptr = malloc(alloc);
	GLOBAL_MEMORY += alloc;
	return ptr;
}

Hum, tu ne t'occupes pas du tout de la valeur transmise. Ca commence mal

. Peut-être que malloc(); va faire le boulot alors.

Voila un extrait de la documentation de malloc (); :

Code :

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

1
2
3
The malloc() and calloc() functions return a pointer to the allocated memory, which is suitably  aligned  for  any  built-in
       type.   On  error,  these  functions return NULL.  NULL may also be returned by a successful call to malloc() with a size of
       zero, or by a successful call to calloc() with nmemb or size equal to zero.

À priori elle renvoie NULL s'il y a une erreur ou si tu demandes une allocation de 0 octet. Donc tools_malloc(); peut renvoyer NULL. Par voie de conséquence strarray_create(int len) retournera NULL.

Tu commences à comprendre qu'il est important de toujours tester les valeurs de retour des fonctions que tu utilises. Et si celles que tu utilises renvoient des valeurs particulières en cas d'erreur il est de bon ton de faire en sorte que tes propres fonctions en fassent autant

. Ca va rendre ton code beaucoup plus robuste et te facilitera la recherche de bogues futurs.

**anate_far_** · 28/12/2021, 20h21

merci beaucoup je vais réécrire mon code de A à Z en appliquant tes conseille. Se sera peut être plus facile après

Erreur de segmentation lor de la redimension d'un tableau

C

Vue hybride

Discussions similaires

Partager

Partager