Discussion :

[sperca]

Bonsoir,

J'ai mis au point quelques fonctions permettant de travailler sur des files. Maintenant pour pouvoir me resservir un jour de ces fonctions j'ai souhaité les rendre plus génériques. J'utilise un le type void*. Pour mettre en place mes files, je me sers d'un buffer tournant.

Les fonctions fonctionnent par exemple si je veux faire une structure de type int. En revanche si j'essaye d'utiliser un type personnel (ici des coordonnées) je ne parviens pas à lire ces coordonnées. Je ne sais pas comment faire...

Je vous montre mon code :

libfifo.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
 
#include "libfifo.h"
 
Fifo*
creer_fifo(u_int taille, size_t type)
{
    Fifo* fifo = NULL;
 
    if ((fifo = malloc(sizeof(Fifo))) &&
	(fifo->tableau = malloc(taille * type)))
    {
	fifo->debut = fifo->fin = fifo->elements = 0;
	fifo->capacite = taille;
    }
    else
    {
	fprintf(stderr, "Allocation fifo impossible\n");
    }
 
    return fifo;
}
 
void
liberer_fifo(Fifo* fifo)
{
    free(fifo->tableau);
    free(fifo);
}
 
int
ajouter_element_fifo(Fifo* fifo, void* element, size_t type)
{
    if (fifo->elements <= fifo->capacite)
    {
	memcpy(&(fifo->tableau[fifo->fin]), element, type);
	fifo->fin = (fifo->fin + 1) % fifo->capacite;
	fifo->elements++;
    }
    else
    {
	fprintf(stderr, "Fifo pleine !\n");
	return 0;
    }
 
    return 1;
}
 
int
supprimer_element_fifo(Fifo* fifo)
{
    if (fifo->elements == 0)
    {
	return 0;
    }
    else
    {
	fifo->debut = (fifo->debut + 1) % fifo->capacite;
	fifo->elements--;
    }
 
    return 1;
}
 
int
main(void)
{
    int i = 0;
    Coord c = {1, 1};
    Fifo* fifo = NULL;
 
    fifo = creer_fifo(10, sizeof(Coord));
    for (i = 0; i < 10; i++)
    {
	ajouter_element_fifo(fifo, &c, sizeof(Coord));
    }
    for (i = 0; i < 10; i++)
    {
	printf("%d %d\n", fifo->tableau[i]->x, fifo->tableau[i]->y);
    }
 
    return 0;
}

libfifo.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef LIBFIFO_H
#define LIBFIFO_H
 
typedef unsigned int u_int;
 
typedef struct coordonnees
{
    u_int x; 
    u_int y;
} Coord;
 
typedef struct fifo
{
    void** tableau;
    int debut;
    int fin;
    int elements;
    int capacite;
} Fifo;
 
Fifo*
creer_fifo(u_int taille, size_t type);
 
void
liberer_fifo(Fifo* fifo);
 
int
ajouter_element_fifo(Fifo* fifo, void* element, size_t type);
 
int
supprimer_element_fifo(Fifo* fifo);
 
#endif

C'est juste un essai et ça ne fonctionne pas... J'aimerais bien comprendre pourquoi.

Merci à vous.

Bye.

PS : Le problème vient surtout de l'utilisation d'un tableau générique, je ne sais pas si ça se fait car je ne le vois pas nulle part...

[orfix]

Salut,

Ce que je peux te dire sans même voir le code c'est qu'il faut être très vigilant en utilisant les void*

Bon après ce que j'ai pu remarquer c'est :

• l'usage de :
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  void** tableau;

  dans ta structure alors qu'un simple :
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  void* tableau;

  aurais suffits vu que tu alloues ta mémoire comme suit :
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  fifo->tableau = malloc(taille * type);

• Le compilateur me signal un déréferencement d'un type void, je rectifie comme suit:
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  4
   
  #define  FIFOCAST(var) ((Coord*)var)
  <...>
   printf("%d %d\n", FIFOCAST(fifo->tableau)[i].x, FIFOCAST(fifo->tableau)[i].y);

  Normale comment veux-tu qu'il sache où est le i ème élément alors qu'il ne connait pas la taille de chaques éléments.
• On regardant l'ajout des éléments je m'arrête sur:
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  memcpy(&(fifo->tableau[fifo->fin]), element, type);

  même soucis qu'avant le compilo doit connaître le type (et donc la taille) de chaque élément :
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  memcpy(&(FIFOCAST(fifo->tableau)[fifo->fin]), element, type);

• Pour finir tu as codé une fonction pour libérer la mémoire utilises là

Bonne continuation

[sperca]

Merci c'est génial ça fonctionne.

Alors par contre maintenant j'ai une autre question, la généricité existe t-elle vraiment C ? Car ici par exemple, elle n'existe pas vraiment puisque je dois caster à l'ajout d'un élément et à la lecture.

Donc elle existe mais pas quand ça touche aux données ?

Parce qu'ici la macro, m'oblige à recompiler la bibliothèque pour un type de données différent.

Merci.

Bye.

[orfix]

Ce que tu peux faire c'est eviter les castes pour les fonctions de ta lib pour ne pas te lier à un type de données particuliers, les castes seront côtés utilisateur, lui seule sauras comment et quoi faire avec ces données chacun son boulot.
tu remplaces donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

memcpy(&(FIFOCAST(fifo->tableau)[fifo->fin]), element, type);

par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

memcpy(fifo->tableau+(fifo->fin * type), element, type);

P.S : Le nom de la macro est peut-être mal choisit

[sperca]

Merci ;-)

Donc je vais me renseigner un peu sur la signification des [] pour les tableaux en C pour pouvoir m'en passer dans ces cas là.

Problème résolu :-p.