De void* à int

Version imprimable

Voir 40 message(s) de cette discussion en une page

08/07/2009, 19h24
Greyfar

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

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 ! :aie:
08/07/2009, 19h59
orfix
il faut caster le pointeur :
Code:

1 2 return *(int *)pltAtt->data;
08/07/2009, 20h20
nicolas.sitbon
Citation:
Envoyé par ssmario2

il faut caster le pointeur :

Code:

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.
08/07/2009, 21h00
Greyfar
Citation:
Envoyé par ssmario2

il faut caster le pointeur :

Code:

1 2 return *(int *)pltAtt->data;
J'ai essayé ce que tu m'as dit mais j'obtiens le même message d'erreur ! :(
08/07/2009, 21h07
Greyfar

Citation:

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':mrgreen:) aide les gars.
08/07/2009, 21h08
Jean-Marc.Bourguet

Citation:

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

Citation:

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:

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:

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:

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);
    }
  }
}

08/07/2009, 21h20
Greyfar

Donc vous trouverez la fonction dans atterrissage.c. La définition de itAtt est dans atterrissage.h.
08/07/2009, 22h36
orfix
Tu ne fournis pas tous les fichiers nécessaire à la compilation.

Citation:

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:

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

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

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. :?
08/07/2009, 22h43
Greyfar

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

SLL.h

Code:

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:

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:

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:

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:

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;
}

08/07/2009, 23h11
nicolas.sitbon

Citation:

Envoyé par ssmario2

Je n'ai pas compris. :?

mea culpa, je croyais que tu lui faisais transtyper un void* en int.
08/07/2009, 23h31
Greyfar

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

quand tu déclares :
Code:

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:

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.

08/07/2009, 23h40
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é
08/07/2009, 23h51
Greyfar

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 :lol:
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 ?
08/07/2009, 23h55
Greyfar

Citation:

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 :P
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 ?
08/07/2009, 23h56
nicolas.sitbon

Citation:

Envoyé par Greyfar

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

voir mon dernier post.
08/07/2009, 23h57
orfix

Non, relis le message de nicolas.sitbon :

Citation:

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 :aie:
08/07/2009, 23h57
nicolas.sitbon

Citation:

Envoyé par Greyfar

Ce que tu as dit m'intéresse puisque je n'y comprends rien :P
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/

Voir 40 message(s) de cette discussion en une page