Référence du fichier list.c

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

#include "list.h"
#include <string.h>
#include <assert.h>

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

Aller au code source de ce fichier.

Fonctions
list_t	list_new (size_t data_size)
	Créé une nouvelle liste. Plus de détails...
void	list_delete (list_t list)
	Détruit une liste. Plus de détails...
void	list_insert (list_t *list, void *el, size_t index)
	Insère un élément dans une liste. Plus de détails...
void	list_erase (list_t *list, size_t index)
	Supprime un élément d’une liste. Plus de détails...
void	list_set (list_t list, void *el, size_t index)
	Modifie un élément dans une liste. Plus de détails...
void *	list_get (list_t list, size_t index)
	function description 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.c.

Documentation des fonctions

list_delete()

void 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()

void 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()

void* list_get	(	list_t	list,
		size_t	index
	)

function description

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()

void 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()

list_t 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()

void 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.