Cesse de fonctionner en fin d'exécution

Version imprimable

Bonjour,

Alors je débute en C, et il à pas mal de chose que je catch mal, que ce soit niveau code ou niveau environnement de Dev. Et la je pense que ma question se rapporte plus à une mauvaise configuration de mon EDI. (Mais en vrai j'en sais rien c'est pourquoi je suis là).

J'ai un programme assez light. Dont voici le main :
Code:

1 2 3 4 5 6 7 8 9 10 11 int main() { t_list* liste1; liste1 = list_new(10); list_append(liste1, 5); list_display((*liste1)); list_append(liste1, 6); list_display((*liste1)); return 0; }
j'ai une structure t_list. Qui contient un tableau de int, et d'autre élément du type int
list_new sert à créer cette structure.
list_append à ajouter un élément dans mon tableau de int.
list_display affiche tout les élément de ma liste.

Quand je l’exécute tous semble bien ce passer

Citation:

Liste creee
Element ajoutee
5
Element ajoutee
5 6

Process returned -1073741819 (0xC0000005) execution time : 1.968 s
Press any key to continue.

Mais à la fin j'ai une fenêtre qui me dis que mon .exe à cessé de fonctionner. Je ne comprend pas pourquoi et d'où ça vient.

Edit : j'ai oublié le plus important. Mon IDE est codeblocks

14/11/2013, 11h40
Metalman

Euh... quelle est l'IDE du coup ? Et l'OS ? (surtout : la version de Windows on va dire :P)
Quels sont les includes ? (pour avoir une idée exacte de ce qui "pourrait" être appelé avant et après le main ! :P)

EDIT : OK ! CodeBlocks

EDIT2 : tu es sûr de ton afficheur de liste "si" plus de 1 élément ?
Essaye d'ajouter un printf de test "après" ton 2e display pour voir s'il se fait.

l'os est windows 7 32 bits
les includes présent sont :

Code:

1
2
#include <stdio.h>
#include <stdlib.h>

les fonctions

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
t_list* list_new (unsigned int max)
{
    t_list* uneListe;
    uneListe = malloc(max * sizeof(int));
    uneListe->max = max;
    uneListe->length = 0;
    printf("Liste creee\n");
 
    return uneListe;
}
 
void list_append(t_list* list, int value)
{
    if(list->length == list->max)
    {
        printf("Element maximum de la liste atteint\n");
    }
    else
    {
        list->data[list->length] = value;
        list->length++;
        printf("Element ajoutee\n");
    }
}
 
void list_display(t_list list)
{
    int i;
    for(i = 0; i < list.length; i++)
    {
        printf("%d ", list.data[i]);
    }
    printf("\n");
}

14/11/2013, 11h48
Médinoc
- list_new alloue la place pour les entiers, mais pas pour le reste de la structure.
  - D'ailleurs, pourrais-tu poster la définition de la structure également?
- Est-ce normal que list_display prenne en paramètre une copie de la structure (avec un probable problème de slicing si tu utilises une structure à dimension variable) au lieu d'un pointeur const vers celle-ci?
14/11/2013, 11h55
MarieKisSlaJoue
Citation:
Envoyé par Médinoc

list_new alloue la place pour les entiers, mais pas pour le reste de la structure.

D'ailleurs, pourrais-tu poster la définition de la structure également?
Est-ce normal que list_display prenne en paramètre une copie de la structure (avec un probable problème de slicing si tu utilises une structure à dimension variable) au lieu d'un pointeur const vers celle-ci?
Je n'avais pas penser à la taille de la structure en effet qui ne dois pas correspondre avec la taille que je lui donne.

Pour info la définition de la structure est celle ci.
Code:

1 2 3 4 5 6 typedef struct { int* data; unsigned int length; unsigned int max; }t_list;
du coup je devrai peut être plutôt faire

Code:

uneListe = malloc(sizeof(t_list) + (sizeof(int * max)))

Pour la question sur list_display on ma donner la signature de la fonction comme ça. Ca ma paru bizarre aussi. Mais j'ai pas chercher à comprendre plus loin, j'ai fait avec.

La structure n'est pas à dimension variable pour le moment.

edit : j'avais écris n'importe quoi dans mes idée...

J'ai vu aussi que tu oubliais de régler data.
Si tu veux utiliser un seul buffer, tu peux faire comme ceci, mais tu t'exposes potentiellement à des problèmes d'alignement sur des plate-formes ésotériques:
Code:

1 2 3 4 5 6 7 8 9 10 11 t_list* list_new (unsigned int max) { t_list* uneListe; uneListe = malloc(max * sizeof(int) + sizeof *uneListe); uneListe->data = (int*)(uneListe+1); uneListe->max = max; uneListe->length = 0; printf("Liste creee\n"); return uneListe; }

14/11/2013, 13h09
MarieKisSlaJoue

Ok très bien tous fonctionne. Mais peut tu m'expliquer cette ligne ?

Code:

uneListe->data = (int*)(uneListe+1);

Je comprend que mon champ data, prend l'adresse de.... je ne sais pas quoi en fait.

A quoi correspond uneListe+1 ? Et pourquoi il était important de la préciser ?

Merci d'avance.

Il prend l'adresse de la zone mémoire située juste après la structure elle-même (vu qu'on a alloué assez de place pour les deux).
Si on ne précise pas data, il pointera dans le vide --> segfault assurée.

En fait, c'est une construction assez proche de la structure dite "à taille variable", qui est construite ainsi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <stddef.h> /*Pour la macro offsetof*/ #include <stdlib.h> typedef struct { unsigned int length; unsigned int max; int data[1]; /*Avec un compilo récent, on peut mettre [0] à la place, mais ça ne change pas grand-chose*/ } t_list; t_list* list_new (unsigned int max) { t_list* uneListe; uneListe = malloc(max * sizeof(int) + offsetof(t_list, data)); uneListe->max = max; uneListe->length = 0; printf("Liste creee\n"); return uneListe; }
L'avantage de cette manière est qu'on est sûr que les contraintes d'alignement sont respectées quelle que soit l'architecture.

14/11/2013, 13h28
MarieKisSlaJoue

Ok très bien j'ai compris. Merci de ton explication.