Problème avec typedef

gcc -Wall -Wextra main.c

#include <stdlib.h>
//#include "Sceau.h"
#include "listSceau.h"

#define TAILLE_MAX 10
#define TAILLE_NOMBRE 4

int  main(void)
{

  listSceau ls;
  Sceau l0 = NULL;

  /* do something with ls and l0 */
  (void) ls;
  (void) l0;

  return 0;
}

#ifndef LISTSCEAU_H
#define LISTSCEAU_H

typedef struct ElementSceau
{
  char *nombre;
  struct ElementSceau *suivant;
}ElementSceau;

/* Définition d'une Sceaue */
typedef struct Sceau
{
  int taille;
  struct ElementSceau *debut;
  struct ElementSceau *fin;
}*Sceau;
  
typedef Sceau listSceau[16];

#endif /* LISTSCEAU_H */

• le typedef ligne 11 masque un pointeur vers un type struct qui porte le même nom que l'étiquette de la struct
• le typedef en ligne 18 n'a aucun sens pour moi ... tu définis listSceau[16] comme un alias de Sceau qui est lui même un pointeur sur struct Sceau....

• Le nommage est améliorable : ce que tu appelles

  struct Sceau

  devrait s'appeler logiquement

  struct ListeSceau

  ;

• typedef Sceau listSceau[16];

  n'a pas de sens :
  • soit tu veux déclarer une variable globale nommée listSceau qui fait la taille de 16 instances de type Sceau, et dans ce cas il faut juste écrire

    Sceau listSceau[16

    ];
  • soit tu veux définir un type qui permet de nommer un tableau statique de 16 objets de type

    Sceau

    (ce qui est une mauvaise idée) il aurait fallu écrire

    typedef Sceau[16] listSceau

    .

ma_structure_t

typedef struct _ma_structure_t {
  // ...
} ma_structure_t;

typedef struct ma_structure_t {
  // ...
} ma_structure_t;

malloc

free

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

typedef struct ma_structure_t {
  int attribut1;
  char attribut2;
} ma_structure_t;

int main(){
    unsigned n = 15;
    ma_structure_t * mes_structures = (ma_structure_t *) malloc(n * sizeof(ma_structure_t));
    if (mes_structures) {
        // ...
        free(mes_structures);
    } else {
        fprintf(stderr, "Pas assez de mémoire");
        return 1;
    }
}

ma_structure_t

n

• Une liste est bien adaptée si tu as fréquemment des éléments à supprimer indépendamment de leur positions, mais si par exemple tu ne supprimes que le premier ou le dernier élément, tu peux faire beaucoup plus simple avec des tableaux. Il est alors judicieux d'envelopper le tableau dans une structure qui indique l'adresse de début et l'adresse de fin et qui déclenche une réallocation en cas de besoin.
• Pour un tableau, le temps d'accès à un élément se fait en O(1) quelle que soit la taille du tableau.
• Pour une liste, le temps d'accès à un élément se fait en O(n).

typedef struct maillon_t {
    //struct maillon_t * precedent;
    struct maillon_t * suivant;
    int donnee;
} maillon_t;

suivant

precedent

NULL

int donnee

void *

typedef struct maillon_t {
    //struct maillon_t * precedent;
    struct maillon_t * suivant;
    void * donnee;
} maillon_t;

typedef

liste_t

struct maillon_t

typedef struct maillon_t liste_t;

struct maillon_t *

typedef struct maillon_t * liste_t;

ma_structure.mon_attribut

pointeur_structure->mon_attribut

typedef struct maillon_t liste_t;

typedef struct liste_t {
    maillon_t * debut;
    maillon_t * fin;
    unsigned taille;
} liste_t;

• list.h

• list.c