Référence du fichier list.h

Fonctions de gestion de liste. Plus de détails...

#include "gl4dummies.h"
#include <stdlib.h>

Graphe des dépendances par inclusion de list.h:

Ce graphe montre quels fichiers incluent directement ou indirectement ce fichier :

Aller au code source de ce fichier.

Structures de données
struct	_list_t
struct	list_t
	Liste chaînée dynamique. Plus de détails...

Définitions de type
typedef struct list_t	list_t

Fonctions
GL4DAPI list_t GL4DAPIENTRY	list_new (size_t data_size)
	Créé une nouvelle liste. Plus de détails...
GL4DAPI void GL4DAPIENTRY	list_delete (list_t list)
	Détruit une liste. Plus de détails...
GL4DAPI void GL4DAPIENTRY	list_insert (list_t *list, void *el, size_t index)
	Insère un élément dans une liste. Plus de détails...
GL4DAPI void GL4DAPIENTRY	list_erase (list_t *list, size_t index)
	Supprime un élément d’une liste. Plus de détails...
GL4DAPI void GL4DAPIENTRY	list_set (list_t list, void *el, size_t index)
	Modifie un élément dans une liste. Plus de détails...
GL4DAPI void *GL4DAPIENTRY	list_get (list_t list, size_t index)
	Retourne un pointeur vers un élément d’une liste. Plus de détails...

Description détaillée

Fonctions de gestion de liste.

Auteur

Kevin HAVRANEK mzart.nosp@m.ek@h.nosp@m.otmai.nosp@m.l.fr

Date

Mars 17, 2015

Définition dans le fichier list.h.

Documentation des définitions de type

list_t

typedef struct list_t list_t

Documentation des fonctions

list_delete()

GL4DAPI void GL4DAPIENTRY list_delete

(

list_t

list

)

Détruit une liste.

Supprime chaque élément de la liste list avant de détruire la liste elle-même.
Attention ! Si les éléments stockés doivent être détruits via un destructeur spécial, ce dernier ne sera pas exécuté lors de l’appel de cette fonction !

Paramètres

list

                              {
  struct _list_t *current, *next;
 
  for (current = list.begin; current != NULL; current = next) {
    next = current->next;
    free(current->data);
    free(current);
  }
}

Références list_t::begin, _list_t::data, et _list_t::next.

list_erase()

GL4DAPI void GL4DAPIENTRY list_erase	(	list_t *	list,
		size_t	index
	)

Supprime un élément d’une liste.

Supprime un élément de la liste list situé à l’index index. Chaque élément suivant l’élément supprimé verra donc son index décrémenté de 1.
Attention ! Si les éléments stockés doivent être détruits via un destructeur spécial, ce dernier ne sera pas exécuté lors de l’appel de cette fonction !

Paramètres

list	Liste dans laquelle l’élément doit être détruit
index	Index de l’élément devant être détruit

                                            {
  struct _list_t *current, *prev;
  size_t i;
 
  assert(index < list->size);
 
  list->size--;
 
  prev = NULL;
  current = list->begin;
  for (i = 0; i < index; i++) {
    prev = current;
    current = current->next;
  }
 
  if (prev != NULL)
    prev->next = current->next;
  else
    list->begin = current->next;
 
  free(current->data);
  free(current);
}

Références list_t::begin, _list_t::data, _list_t::next, et list_t::size.

list_get()

GL4DAPI void* GL4DAPIENTRY list_get	(	list_t	list,
		size_t	index
	)

Retourne un pointeur vers un élément d’une liste.

Retourne un pointeur vers un élément d’une liste.

Cette fonction renvoie un pointeur vers l’élément situé à l’index index dans la liste list.

Paramètres

list	Liste contenant l’élément souhaité
index	Index de l’élément souhaité

Renvoie

Renvoie un pointeur vers l’élément d’index index

                                           {
  struct _list_t *current;
  size_t i;
 
  assert(index < list.size);
 
  current = list.begin;
  for (i = 0; i < index; i++) {
    current = current->next;
  }
 
  return current->data;
}

Références list_t::begin, _list_t::data, _list_t::next, et list_t::size.

list_insert()

GL4DAPI void GL4DAPIENTRY list_insert	(	list_t *	list,
		void *	el,
		size_t	index
	)

Insère un élément dans une liste.

Insère un nouvel élément el dans la liste list à l’index index, avant l’élément se trouvant précédemment à ce même index (ce dernier et les éléments suivant subissant alors un décalage d’un rang). L’élément el est copié dans une nouvelle cellule de la liste, et l’élément el passé en paramètre et l’élément dans la liste à la fin de l’exécution de cette fonction ne sont donc pas le même objet.

Paramètres

list	Liste dans laquelle est insérée le nouvel élément
el	Nouvel élément à insérer
index	Index auquel insérer le nouvel élément

                                                       {
  struct _list_t *current, *prev, *new_ptr;
  size_t i;
 
  list->size = (index < list->size) ? (list->size + 1) : (index + 1);
 
  prev = NULL;
  current = list->begin;
  for (i = 0; i < index; i++) {
    if (current->next == NULL) {
      current->next = malloc(sizeof *current->next);
      assert(current->next);
 
      current->next->data = malloc(list->data_size);
      assert(current->next->data);
 
      current->next->next = NULL;
 
    }
 
    prev = current;
    current = current->next;
  }
 
  new_ptr = malloc(sizeof *new_ptr);
  assert(new_ptr);
 
  new_ptr->data = malloc(list->data_size);
  assert(new_ptr->data);
 
 
  memcpy(new_ptr->data, el, list->data_size);
 
  if (prev != NULL) {
    prev->next = new_ptr;
  } else {
    list->begin = new_ptr;
  }
 
  new_ptr->next = current;
}

Références list_t::begin, _list_t::data, list_t::data_size, _list_t::next, et list_t::size.

list_new()

GL4DAPI list_t GL4DAPIENTRY list_new

(

size_t

data_size

)

Créé une nouvelle liste.

Créé une liste vide d’éléments de taille data_size et renvoie un pointeur sur ladite liste

Paramètres

data_size

Renvoie

Retourne un pointeur sur la liste créée

                                  {
  list_t list;
 
  list.begin = malloc(sizeof *list.begin);
  assert(list.begin);
 
  list.size = 0;
  list.data_size = data_size;
  list.begin->data = malloc(data_size);
  assert(list.begin->data);
 
  list.begin->next = NULL;
 
 
  return list;
}

Références list_t::begin, _list_t::data, list_t::data_size, _list_t::next, et list_t::size.

list_set()

GL4DAPI void GL4DAPIENTRY list_set	(	list_t	list,
		void *	el,
		size_t	index
	)

Modifie un élément dans une liste.

Cette fonction remplace la valeur de l’élément de la liste list situé à l’index index par la valeur de l’élément el qui sera copié.
Attention ! Si l’élément précédent doit être détruit via un destructeur spécial, ce dernier ne sera pas exécuté via cette fonction !

Paramètres

list	Liste dans laquelle l’élément doit être modifié
el	Élément dont les valeurs seront copiées
index	Index de l’élément à modifier

                                                   {
  struct _list_t *current;
  size_t i;
 
  assert(index < list.size);
 
  current = list.begin;
  for (i = 0; i < index; i++) {
    current = current->next;
  }
 
  memcpy(current->data, el, list.data_size);
}

Références list_t::begin, _list_t::data, list_t::data_size, _list_t::next, et list_t::size.