De void* à int

**Greyfar** · 08/07/2009, 19h24

Bonjour tout le monde !
Je suis confronté à un problème de compatibilité entre types.
Voici d'abord ma fonction:

Code :

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

1
2
3
int itAtt_carb(itAtt* pItAtt) {
  return (int)(*(pItAtt->data));
}

Sachez que data est de type void *
Je voudrai récupérer la valeur (un entier) pointée par data et la retourner à la fonction. Mais le compilateur grogne sur la ligne return (int)(*(pItAtt->data));, il me dit : error: dereferencing pointer to incomplete type

Toute aide de votre part est la bienvenue !

**orfix** · 08/07/2009, 19h59

il faut caster le pointeur :

Code :

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

1
2
 
return *(int *)pltAtt->data;

**nicolas.sitbon** · 08/07/2009, 20h20

Envoyé par ssmario2

il faut caster le pointeur :

Code :

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

1
2
 
return *(int *)pltAtt->data;

non, ça n'est pas une solution, il faut soit modifier le prototype de la fonction, soit renvoyé un int.

**Greyfar** · 08/07/2009, 21h00

Envoyé par ssmario2

il faut caster le pointeur :

Code :

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

1
2
 
return *(int *)pltAtt->data;

J'ai essayé ce que tu m'as dit mais j'obtiens le même message d'erreur !

**Greyfar** · 08/07/2009, 21h07

Envoyé par nicolas.sitbon

non, ça n'est pas une solution, il faut soit modifier le prototype de la fonction, soit renvoyé un int.

De quelle manière devrai-je modifier le prototype, sachant que de toute façon je veux renvoyer un int ? En fait, je ne comprends pas pourquoi ça ne fonctionne pas... J'ai essayé pas mal de choses déjà avec toujours le même message d'erreur. Si tu pouvais être plus clair...
En tout cas, merci pour votre (tentative d'

) aide les gars.

**Jean-Marc.Bourguet** · 08/07/2009, 21h08

Envoyé par Greyfar

J'ai essayé ce que tu m'as dit mais j'obtiens le même message d'erreur !

Est-ce que tu as une définition de itAtt en vue (j'ai l'impression qu'il n'y a qu'une déclaration).

**Greyfar** · 08/07/2009, 21h18

Envoyé par Jean-Marc.Bourguet

Est-ce que tu as une définition de itAtt en vue (j'ai l'impression qu'il n'y a qu'une déclaration).

En fait itAtt est un item de liste chainee que j'ai redéfini par le biais de typedef. Je vais livrer mes sources si vous voulez vous pencher sur la question:
SLL.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
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
#include <stdio.h>
#include <stdlib.h>
#include "SLL.h"
 
/*Maillon de la liste*/
typedef struct item {
    struct item *next;
    void *data;
} item_s;
 
/*Liste simplement chainée (Single-Linked List)*/
struct sll {
  item_s *p_start; //Premier élément de la liste
  item_s *list; //Pointe sur l'élément courant
};
 
sll_s* sll_new(void)
{
    sll_s *p_sll = malloc(sizeof *p_sll);
 
    if (p_sll) {
	item_s *p_l = malloc(sizeof *p_l);
 
	if (p_l) {
	    p_l->data = NULL;
	    p_l->next = NULL;
 
	    p_sll->p_start = p_l;
	    p_sll->list = NULL;
	} else {
	    fprintf(stderr, "Memoire insufisante\n");
	    exit(EXIT_FAILURE);
	}
    } else {
	fprintf(stderr, "Memoire insufisante\n");
	exit(EXIT_FAILURE);
    }
    return p_sll;
}
 
void sll_insert(sll_s * p_sll, void *data)
{
    if (p_sll) {
	item_s *p_l = p_sll->list;
	item_s *p_n = NULL;
 
	p_n = malloc(sizeof(*p_n));
	if (p_n) {
	    p_n->data = data;
	    if (p_l == NULL) {
		p_sll->p_start->next = p_n;
		p_n->next = NULL;
	    } else {
		p_n->next = p_l->next;
		p_l->next = p_n;
	    }
	    p_sll->list = p_n;
	} else {
	    fprintf(stderr, "Memoire insuffisante\n");
	    exit(EXIT_FAILURE);
	}
    }
}
 
void sll_insert_first(sll_s* p_sll, void* data) {
  if(p_sll) {
    if(p_sll->p_start) {
      item_s* p_n = NULL;
      p_n = malloc(sizeof(*p_n));
      if(p_n) {
	p_n->data = data;
	p_n->next = p_sll->p_start;
	p_sll->p_start = p_n;
      }
      else {
	fprintf(stderr, "Memoire insuffisante\n");
	exit(EXIT_FAILURE);
      }
    }
    else {
      sll_insert(p_sll, data);
    }
  }
}
 
void sll_removeNext(sll_s * p_sll)
{
    if (p_sll && p_sll->list) {
	item_s *p_l = p_sll->list;
	item_s *p_n = NULL;
 
	p_n = p_l->next;
	p_l->next = p_n->next;
	free(p_n);
	p_n = NULL;
    }
}
 
void sll_removeFirst(sll_s * p_sll)
{
    if (p_sll) {
	p_sll->list = p_sll->p_start;
	sll_removeNext(p_sll);
    }
}
 
void sll_next(sll_s * p_sll)
{
    if (p_sll && p_sll->list) {
	p_sll->list = p_sll->list->next;
    }
}
 
void *sll_data(sll_s * p_sll)
{
    return ((p_sll && p_sll->list) ? p_sll->list->data : NULL);
}
 
void sll_first(sll_s * p_sll)
{
    if (p_sll) {
	p_sll->list = p_sll->p_start->next;
    }
}
 
void sll_last(sll_s * p_sll)
{
    if (p_sll) {
	while (p_sll->list->next != NULL) {
	    sll_next(p_sll);
	}
    }
}
 
size_t sll_sizeof(sll_s * p_sll)
{
    size_t n = 0;
 
    if (p_sll) {
	sll_first(p_sll);
	while (p_sll->list != NULL) {
	    n++;
	    sll_next(p_sll);
	}
    }
    return n;
}
 
void sll_delete(sll_s ** pp_sll)
{
    if (pp_sll && *pp_sll) {
	sll_first(*pp_sll);
 
	while ((*pp_sll)->list->next != NULL) {
	    sll_removeNext(*pp_sll);
	}
	sll_removeFirst(*pp_sll);
	free((*pp_sll)->list);
	(*pp_sll)->list = NULL;
	free(*pp_sll), *pp_sll = NULL;
    }
}

atterrissage.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include "SLL.h"
 
typedef struct item itAtt;
typedef struct sll lAtterrissage;
 
int itAtt_carb(itAtt* pItAtt);
int latt_carb(lAtterrissage* latt);
void latt_insert(lAtterrissage* latt, int carb);

atterrissage.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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "atterrissage.h"
 
int itAtt_carb(itAtt* pItAtt) {
  return *(int *)pItAtt->data;
}
 
int latt_carb(lAtterrissage* latt) {
  return ((int)latt->list->data);
}
 
void latt_insert(lAtterrissage* latt, int carb) {
  int* pCarb = NULL;
  *pCarb = carb;
  if(latt) {
    if(latt->pstart != NULL) {
      sll_first(latt);
      if(latt_carb(latt) > carb) {
	sll_insert_first(latt, pCarb);
      }
      else {
	while(itAtt_carb(latt->list->next) < carb) {
	  sll_next(latt);
	}
	sll_insert(latt, pCarb);
      }
    }
    else {
      sll_insert(latt, pCarb);
    }
  }
}

**Greyfar** · 08/07/2009, 21h20

Donc vous trouverez la fonction dans atterrissage.c. La définition de itAtt est dans atterrissage.h.

**orfix** · 08/07/2009, 22h36

Tu ne fournis pas tous les fichiers nécessaire à la compilation.

Envoyé par Greyfar

J'ai essayé ce que tu m'as dit mais j'obtiens le même message d'erreur !

sur la même ligne tu es sûr ? parce que je vois que tu n'as pas tout changé :

Code atterrissage.c :

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

1
2
3
4
5
 
int latt_carb(lAtterrissage* latt) {
    return *(int*)latt->list->data;
    /* return ((int)latt->list->data); */
}

au passage :

Code atterrissage.c :

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

1
2
if(latt->p_start != NULL) {

Envoyé par nicolas.sitbon

non, ça n'est pas une solution, il faut soit modifier le prototype de la fonction, soit renvoyé un int.

Je n'ai pas compris.

**Greyfar** · 08/07/2009, 22h43

En fait j'ai changé ce que tu m'as dit au début, mais en réalité j'obtiens le même message d'erreur pour les autres fonctions. Néanmoins ton code n'élimine pas le problème sur ma fonction itAtt_carb().
Je vais reposter tout le code nécessaire à la compilation d'ici quelques minutes...

**Greyfar** · 08/07/2009, 22h52

SLL.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
 
#ifndef H_LISTESIMPLE
#define H_LISTESIMPLE
 
#include <stddef.h>		/* pour size_t */
 
typedef struct sll sll_s;
 
sll_s *sll_new(void);
void sll_insert(sll_s *, void *);
void sll_insert_first(sll_s *, void *);
void sll_removeNext(sll_s *);
void sll_removeFirst(sll_s *);
void sll_next(sll_s *);
void *sll_data(sll_s *);
void sll_first(sll_s *);
void sll_last(sll_s *);
size_t sll_sizeof(sll_s *);
void sll_delete(sll_s **);
 
#endif				/* not H_LISTESIMPLE */

SLL.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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
#include <stdio.h>
#include <stdlib.h>
#include "SLL.h"
 
/*Maillon de la liste*/
typedef struct item {
    struct item *next;
    void *data;
} item_s;
 
/*Liste simplement chainée (Single-Linked List)*/
struct sll {
  item_s *p_start; //Premier élément de la liste
  item_s *list; //Pointe sur l'élément courant
};
 
sll_s* sll_new(void)
{
    sll_s *p_sll = malloc(sizeof *p_sll);
 
    if (p_sll) {
	item_s *p_l = malloc(sizeof *p_l);
 
	if (p_l) {
	    p_l->data = NULL;
	    p_l->next = NULL;
 
	    p_sll->p_start = p_l;
	    p_sll->list = NULL;
	} else {
	    fprintf(stderr, "Memoire insufisante\n");
	    exit(EXIT_FAILURE);
	}
    } else {
	fprintf(stderr, "Memoire insufisante\n");
	exit(EXIT_FAILURE);
    }
    return p_sll;
}
 
void sll_insert(sll_s * p_sll, void *data)
{
    if (p_sll) {
	item_s *p_l = p_sll->list;
	item_s *p_n = NULL;
 
	p_n = malloc(sizeof(*p_n));
	if (p_n) {
	    p_n->data = data;
	    if (p_l == NULL) {
		p_sll->p_start->next = p_n;
		p_n->next = NULL;
	    } else {
		p_n->next = p_l->next;
		p_l->next = p_n;
	    }
	    p_sll->list = p_n;
	} else {
	    fprintf(stderr, "Memoire insuffisante\n");
	    exit(EXIT_FAILURE);
	}
    }
}
 
void sll_insert_first(sll_s* p_sll, void* data) {
  if(p_sll) {
    if(p_sll->p_start) {
      item_s* p_n = NULL;
      p_n = malloc(sizeof(*p_n));
      if(p_n) {
	p_n->data = data;
	p_n->next = p_sll->p_start;
	p_sll->p_start = p_n;
      }
      else {
	fprintf(stderr, "Memoire insuffisante\n");
	exit(EXIT_FAILURE);
      }
    }
    else {
      sll_insert(p_sll, data);
    }
  }
}
 
void sll_removeNext(sll_s * p_sll)
{
    if (p_sll && p_sll->list) {
	item_s *p_l = p_sll->list;
	item_s *p_n = NULL;
 
	p_n = p_l->next;
	p_l->next = p_n->next;
	free(p_n);
	p_n = NULL;
    }
}
 
void sll_removeFirst(sll_s * p_sll)
{
    if (p_sll) {
	p_sll->list = p_sll->p_start;
	sll_removeNext(p_sll);
    }
}
 
void sll_next(sll_s * p_sll)
{
    if (p_sll && p_sll->list) {
	p_sll->list = p_sll->list->next;
    }
}
 
void *sll_data(sll_s * p_sll)
{
    return ((p_sll && p_sll->list) ? p_sll->list->data : NULL);
}
 
void sll_first(sll_s * p_sll)
{
    if (p_sll) {
	p_sll->list = p_sll->p_start->next;
    }
}
 
void sll_last(sll_s * p_sll)
{
    if (p_sll) {
	while (p_sll->list->next != NULL) {
	    sll_next(p_sll);
	}
    }
}
 
size_t sll_sizeof(sll_s * p_sll)
{
    size_t n = 0;
 
    if (p_sll) {
	sll_first(p_sll);
	while (p_sll->list != NULL) {
	    n++;
	    sll_next(p_sll);
	}
    }
    return n;
}
 
void sll_delete(sll_s ** pp_sll)
{
    if (pp_sll && *pp_sll) {
	sll_first(*pp_sll);
 
	while ((*pp_sll)->list->next != NULL) {
	    sll_removeNext(*pp_sll);
	}
	sll_removeFirst(*pp_sll);
	free((*pp_sll)->list);
	(*pp_sll)->list = NULL;
	free(*pp_sll), *pp_sll = NULL;
    }
}

atterrissage.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include "SLL.h"
 
typedef struct item itAtt;
typedef struct sll lAtterrissage;
 
int itAtt_carb(itAtt* pItAtt);
int latt_carb(lAtterrissage* latt);
void latt_insert(lAtterrissage* latt, int carb);

atterrissage.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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "atterrissage.h"
 
int itAtt_carb(itAtt* pItAtt) {
  return *(int *)pItAtt->data;
}
 
int latt_carb(lAtterrissage* latt) {
  return *(int*)latt->list->data;
  /* return ((int)latt->list->data); */
}
 
void latt_insert(lAtterrissage* latt, int carb) {
  int* pCarb = NULL;
  *pCarb = carb;
  if(latt) {
    if(latt->p_start != NULL) {
      sll_first(latt);
      if(latt_carb(latt) > carb) {
	sll_insert_first(latt, pCarb);
      }
      else {
	while(itAtt_carb(latt->list->next) < carb) {
	  sll_next(latt);
	}
	sll_insert(latt, pCarb);
      }
    }
    else {
      sll_insert(latt, pCarb);
    }
  }
}

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include <stdio.h>
#include <stdlib.h>
 
#include "atterrissage.h"
 
 
int main(int argc, char** argv) {
 
  return 0;
}

**nicolas.sitbon** · 08/07/2009, 23h11

Envoyé par ssmario2

Je n'ai pas compris.

mea culpa, je croyais que tu lui faisais transtyper un void* en int.

**Greyfar** · 08/07/2009, 23h31

Apparement je ne suis pas le seul à avoir flanché sur ces bouts de code ! Si quelque chose ne semble pas clair dans ce que je veux faire ou dans mon code n'hésitez pas à me le signaler, c'est la premiere fois que je crée une discussion...

**orfix** · 08/07/2009, 23h37

quand tu déclares :

Code atterissage.h :

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

1
2
3
4
#include "SLL.h"
<...>
typedef struct item itAtt;
typedef struct sll lAtterrissage;

struct item et struct sll ne sont pas connus (ils ne sont pas non plus déclarer dans SLL.h), pour le compilateur c'est des types incomplets (leur taille n'est pas connues) il ne peut donc déréférencer des pointeurs sur ces types.

le plus simple est de déplacer :

Code SLL.c :

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

1
2
3
4
5
6
7
8
9
10
11
/*Maillon de la liste*/
typedef struct item {
    struct item *next;
    void *data;
} item_s;
 
/*Liste simplement chainée (Single-Linked List)*/
struct sll {
    item_s *p_start; //Premier élément de la liste
    item_s *list; //Pointe sur l'élément courant
};

Vers SLL.h.

**nicolas.sitbon** · 08/07/2009, 23h40

J'ai manqué l'essentiel du premier post, tu as fait un type opaque mais son implémentation est incorrecte. Soit tu mets les getters et les setters de ta structure itAtt dans SLL.c soit tu mets la déclaration de cette même structure dans le .h et non dans le .c, évidemment, la première solution est la meilleure puisqu'elle met en place le principe d'encapsulation.
EDIT: grillé

**Greyfar** · 08/07/2009, 23h51

ssmario2 tu as raison j'ai appliqué ce que tu m'as dit et ça fonctionne ! J'en conclut aussi que je suis vraiment un débile

Donc finalement ça compile sans problème.

Merci pour ton aide. Dois-je en conclure que l'on doit forcément déclarer les structures dans les .h ?

**Greyfar** · 08/07/2009, 23h55

Envoyé par nicolas.sitbon

J'ai manqué l'essentiel du premier post, tu as fait un type opaque mais son implémentation est incorrecte. Soit tu mets les getters et les setters de ta structure itAtt dans SLL.c soit tu mets la déclaration de cette même structure dans le .h et non dans le .c, évidemment, la première solution est la meilleure puisqu'elle met en place le principe d'encapsulation.
EDIT: grillé

Ce que tu as dit m'intéresse puisque je n'y comprends rien

C'est quoi un type opaque ?
Quand tu parles de getters et setters, veux-tu parler des fonctions qui permettent d'agir sur les données des structures ?

Par contre je ne suis pas d'accord avec toi sur le fait que tu veuilles mettre des fonctions en rapport avec itAtt dans les fichiers SLL pour la simple et bonne raison que ces fichiers ne doivent pas être altérés pour spécialiser la liste chainee dans telle ou telle application. Qu'en penses-tu ?

**nicolas.sitbon** · 08/07/2009, 23h56

Envoyé par Greyfar

Dois-je en conclure que l'on doit forcément déclarer les structures dans les .h ?

voir mon dernier post.

**orfix** · 08/07/2009, 23h57

Non, relis le message de nicolas.sitbon :

Envoyé par nicolas.sitbon

J'ai manqué l'essentiel du premier post, tu as fait un type opaque mais son implémentation est incorrecte. Soit tu mets les getters et les setters de ta structure itAtt dans SLL.c soit tu mets la déclaration de cette même structure dans le .h et non dans le .c, évidemment, la première solution est la meilleure puisqu'elle met en place le principe d'encapsulation.

Edit: Grillé à mon tour

**nicolas.sitbon** · 08/07/2009, 23h57

Envoyé par Greyfar

Ce que tu as dit m'intéresse puisque je n'y comprends rien

C'est quoi un type opaque ?
Quand tu parles de getters et setters, veux-tu parler des fonctions qui permettent d'agir sur les données des structures ?

Par contre je ne suis pas d'accord avec toi sur le fait que tu veuilles mettre des fonctions en rapport avec itAtt dans les fichiers SLL pour la simple et bonne raison que ces fichiers ne doivent pas être altérés pour spécialiser la liste chainee dans telle ou telle application. Qu'en penses-tu ?

http://emmanuel-delahaye.developpez....its-donnees-c/

De void* à int

C

Discussions similaires

Partager

Partager