Erreur de segmentation lor de la redimension d'un tableau
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:
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:
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:
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:
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;
} |
