Discussion :

[Greyfar]

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]

il faut caster le pointeur :

Code :

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

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

[nicolas.sitbon]

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]

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.

[Greyfar]

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 !

[Jean-Marc.Bourguet]

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]

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]

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