typedef struct Element Element;
struct Element
{
    int nombre;
    Element* suivant;
};


typedef struct Liste Liste;
struct Liste
{
    Element* premier;
};

Liste* Intialisation()
{
    Liste *liste = (Liste*) malloc (sizeof(*liste));
    Element *element = (Element*) malloc(sizeof(*element));
    if (element == NULL || liste == NULL)
    {
        exit(EXIT_FAILURE);
    }
    element->nombre = 0;
    element->suivant = NULL;
    liste->premier = element;
    return liste;


}

-
Edité par KhaoulaKhichi 14 juin 2022 à 6:26:34

Ce n'est pas un pointeur? Alors c'est quoi?
Tu retournes un pointeur vers un descripteur de liste (ou tête de liste).
Ce qui se trouve devant le nom de la fonction déclare le type de l'objet qui doit être retourné.
Et je ne recommande pas de déclarer des descripteurs de liste de cette façon.

On doit pouvoir avoir une liste vide sans élément.

C'est une autre fonction qui ajoutera l'élément en question.
Tu seras toujours pris avec un élément en trop.
Que se passera-t-il si tu décides de supprimer cet élément?

-
Edité par PierrotLeFou 10 juin 2022 à 6:54:56

 if (liste == NULL || element == NULL)
    {
        exit(EXIT_FAILURE);
    }
 

Tu parles de la ligne 15 ? L'étoile n'est pas mise à gauche du nom de la fonction mais à droite du nom du type : la fonction 'Initialisation' retourne une donnée de type 'Liste*', autrement dit retourne un pointeur sur 'Liste'.

(Je sais, on a le droit  de mettre l'étoile où on veut, mais je trouve plus clair comme a fait KhaoulaKhichi.)

-
Edité par robun 10 juin 2022 à 18:46:17

PierrotLeFou voila pour la suppression ,j'ai testé cette fonction et ca marche .

void suppression(Liste* liste)
{
    Element* aSupprimer= (Element*)malloc(sizeof(*aSupprimer));
    if (liste == NULL)
    {
        exit(EXIT_FAILURE);
    }
    else
    
    {

        
        aSupprimer = liste->premier;
        liste->premier = liste->premier->suivant;
    }
    free (aSupprimer);
}

-
Edité par KhaoulaKhichi 11 juin 2022 à 6:15:49

Tu mets ton free en dehors du if ? Faire un free de NULL te conduira vers une erreur.
(Segmentation fault)

Ça va arriver si tu essaies de supprimer plus d'éléments qu'il y en a dans ta liste.

Si tu veux continuer sur ce genre d'exercice, ça serait bon d'avoir une fonction qui affiche les éléments de ta liste.

-
Edité par PierrotLeFou 11 juin 2022 à 1:42:54

PierrotLeFou a écrit:

Faire un free de NULL te conduira vers une erreur.
(Segmentation fault)

Je ne crois pas ! free de NULL : aucune action n'est effectuée.

Mais, si tu supprimes plus d'élément qu'il y en a, tu vas déréférencer le pointeur NULL et ça c'est le plantage assuré.

Et en plus, il y a une belle fuite mémoire : pourquoi allouer de la mémoire pour aSupprimer, elle est ensuite perdu quand tu affectes l'adresse d'un élément de ta liste.

(il n'est pas utile voire même déconseiller de caster le retour de malloc).

-
Edité par rouIoude 11 juin 2022 à 11:23:53

c'est quoi la différences entre les deux écritures svp(coté technique)

Element* nvelemnt = (Element*)malloc(sizeof(*nvelemnt))

et 

Element* nvelemnt = NULL ;

La première : déclaration d'un pointeur et initialisation de ce pointeur à l'adresse d'une zone mémoire utilisable (créée par 'malloc'). On peut se servir du pointeur, il pointe vers quelque chose.

La deuxième : déclaration d'un pointeur et initialisation à NULL, qui n'est pas (par définition) l'adresse d'une zone mémoire utilisable. On ne peut pas se servir du pointeur, il ne pointe vers rien. Ça sert pour savoir que, pour l'instant, il n'est pas utilisable.

Si on avait déclaré le pointeur sans l'initialiser du tout, sans même le mettre à NULL, il vaudrait une adresse plus ou moins aléatoire (selon les bits restés la zone mémoire où est rangé le pointeur) et presque toujours invalide (sauf coïncidence extraordinaire). Mais on ne le saurait pas.

-
Edité par robun 13 juin 2022 à 9:38:59

C'est que tu ne sais pas à quoi sert malloc : malloc sert à allouer de la mémoire sur le tas, mémoire que tu peux ensuite utiliser pour stocker des données. malloc renvoi l'adresse de la mémoire allouée, adresse que tu affectes à un pointeur, qui te permettras d'y accéder.

Mettre un pointeur à NULL, ça sert à indiquer qu'il ne faut pas l'utiliser en l'état !