Convertion de pointeurs

Version imprimable

Bonjour à tous!
je suis entrain de réaliser un projet et j'ai des erreur de type pointeur lors de ma compilation:

Déclaration de deux type:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct {
    int dep; // arret de depart
    int arr; // arret d' arrivé
    double cout; // le coût d'un arret a l'autre
} ARC;
 
/* les elements du graphe sont des listes chainés
 *  */
typedef struct{
	ARC val;
	struct trajet *suivt;
} Trajet ;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Trajet *ajout_queue(ARC c , Trajet* liste ){
 
    Trajet* nveau= malloc( sizeof(Trajet));
    nveau->val =c;
    nveau->suivt=NULL;
    if ( liste == NULL){
        return nveau;
    }
    else{
        Trajet* temp= liste;
        while( temp->suivt !=NULL){
            temp=temp->suivt;
        }
        temp->suivt =nveau;
        return liste;
    }
}

voici le message d'erreur que j'ai pour les ligne 12 et 14 :

Attention: assignment from incompatible pointer type

Je ne vois pas d'où peut venir l'erreur.
Pouvez vous m'aidez ?
Merci !!!!

temp est un Trajet avec que temp->suivt est un trajet.

Essaye avec :

Code:

1
2
3
4
typedef struct trajet {
	ARC val;
	struct trajet *suivt;
} Trajet ;

Ou :

Code:

1
2
3
4
5
6
struct trajet {
	ARC val;
	struct trajet *suivt;
} ;
 
typedef struct trajet Trajet;

03/05/2012, 14h32
fregolo52

salut

pour être un peu plus "propre", malloc retourne un void *, donc cast le résultat :

Code:

Trajet* nveau= (Trajet*)malloc( sizeof(Trajet));
03/05/2012, 14h34
Bktero

Citation:

Envoyé par fregolo52

pour être un peu plus "propre", malloc retourne un void *, donc cast le résultat

Ce n'est pas la peine :)
http://c.developpez.com/faq/index.ph...#DIVERS_malloc
03/05/2012, 14h58
fregolo52

Citation:

Envoyé par Bktero

Ce n'est pas la peine :)
http://c.developpez.com/faq/index.ph...#DIVERS_malloc

Oui, :oops: alors, on va dire que ça dépend du compilo. (Visual 2008 me claque un warning)
03/05/2012, 15h08
Bousk

Citation:

Envoyé par fregolo52

Oui, :oops: alors, on va dire que ça dépend du compilo. (Visual 2008 me claque un warning)

Peut-être compiles-tu en C++ sur visual 2008 ? :)
03/05/2012, 15h09
Bktero

Arf :calim2:

T'as pas de chance, tu vas être obligé de caster (Visual est pas mal dédié au C++ ? Il prévoit peut-être le coup que ton code C sera porté vers une application en C++ à un moment ou un autre). Par pure curiosité, tu pourrais nous montre le dit warning stp ? :)
03/05/2012, 15h12
Bktero
Citation:

Envoyé par Bousk

Peut-être compiles-tu en C++ sur visual 2008 ? :)

J'y ai pensé, mais (et mes connaissances en C++ sont maigres) j'ai lu que ça devait générer une erreur et non un warning en C++. Je me suis empressé de vérifier avec Codeblocs sous XP :
Code:

1 2 3 4 5 6 7 8 9 10 11 #include <iostream> #include "stdlib.h" using namespace std; int main() { char * pointeur = malloc( 200 ); cout << "Hello world!" << endl; return 0; }
mène à :

Citation:

d:\Documents and Settings\pgradot\Mes documents\Tools SD\A voir\Cplusplus\main.cpp||In function 'int main()':|
d:\Documents and Settings\pgradot\Mes documents\Tools SD\A voir\Cplusplus\main.cpp|8|error: invalid conversion from 'void*' to 'char*'|
d:\Documents and Settings\pgradot\Mes documents\Tools SD\A voir\Cplusplus\main.cpp|8|warning: unused variable 'pointeur'|
||=== Build finished: 1 errors, 1 warnings ===|

J'ai appris qu'il valait mieux caster la valeur retournée de malloc pour rendre le code plus lisible et pour éviter certaines erreurs bêtes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
char * c;
int k = 4;
//quelques lignes de code
c = (char *)malloc(k*sizeof(char));
//on rappelle ici au lecteur que c est un (char *)
 
//On sait que C est un (char *)
c = malloc(k*sizeof(char *)); //on ne s’aperçoit peut être pas tout de suite de l'erreur
c = (char *)malloc(k*sizeof(char *));//ça saute aux yeux puisqu'on sait que cela devrait avoir la forme : (Type *)malloc(k*sizeof(Type));
 
//ou seconde erreur :
c = (char **)malloc(k*sizeof(char *));//on vois directement l'erreur dans ce cas aussi

03/05/2012, 15h36
Bktero

Si ta technique par d'une bonne volonté, elle n'est pas la meilleure réponse au problème.

Si on veut éviter les erreurs de ce type, autant utiliser la forme proposée par Emmanuel Delayes je trouve :

http://emmanuel-delahaye.developpez....ge=Page5#LXXIX

Extrait de XXIX-B. Déterminer la taille sans le type :

Code:

int *p = malloc (sizeof *p);
03/05/2012, 15h54
Neckara

Pour le compilateur c'est du pareil au même.

Lorsqu'un personne externe relis votre code, je trouve que c'est bien de profiter du malloc pour lui rappeler le type de notre variable.
De toute façon, s'il y a une erreur, le compilateur râlera.

Après, je ne pense pas qu'il y ai une grande importance à utiliser l'une ou l'autre solution.

On va entrer dans un débat idéologique, je le sens ^^

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
    char  *l;
    int k = 400;
 
    printf("Taille d'un char : %d\n", sizeof(char));
    printf("On veut en allouer %d\n\n", k);
 
    l = (char *)malloc(k * sizeof(char*)); // rappel mais erreur quand meme
    printf("Espace alloue : %d \n", k * sizeof(char*));
 
    l = malloc( k * sizeof(*l) ); // rappel : c est un pointeur sur char
    printf("Espace alloue : %d \n", k * sizeof(*l));
 
    return 0;
}

compile sans erreur ni warning. Pourtant en sortie du programme :

Citation:

Taille d'un char : 1
On veut en allouer 400

Espace alloue : 1600
Espace alloue : 400

03/05/2012, 16h40
Neckara
L'erreur saute tout de suite aux yeux :
Code:

1 2 (char *)malloc(k * sizeof(char*));
Lorsqu'on va écrire le malloc, on va généralement écrire le type pour le sizeof (ce que l'on veut stocker), puis on va mettre le type pour le cast (copier/coller) en rajoutant un '*', ensuite, si la variable n'est pas du bon type, le compilateur crise. Une telle erreur est donc impossible si on procède de cette manière.

Or, avec le méthode :
Code:

1 2 l = malloc(k * sizeof(* l));
On peut déjà se retrouver dans la situation :
Code:

1 2 3 4 l[0] = malloc(k * sizeof(** l)); l[0][0] = malloc(k * sizeof(*** l)); l[0][0][0] = malloc(k * sizeof(**** l));
Il ne faut pas se tromper dans le nombre de '*'

De plus on est pas sûr d'avoir bien créé un espace pour le type qu'on veut stocker (on veut stocker des int * or l est un int *) et dans ce cas là, on aura l'erreur de compilation lors de l'utilisation de l (et non lors du malloc).

EDIT : Comment fais-tu quand l est un (void *) ?? D'ailleurs question théorique que se passe-t-il alors? Le compilateur crise non?

Je ne dit pas, et je n'ai jamais dit que ta méthode était mauvaise ou que la mienne est meilleurs, mais juste que la méthode que je "défend" est, jusqu'à ce qu'on me prouve le contraire, une méthode valable/propre.

Et que l'utilisation de l'une ou de l'autre méthode est plus un choix du programmeur selon ce qu'il préfère.

EDIT : Serait-il possible de demander une fission du sujet pour éviter de polluer ce sujet?
Je ne suis pas du tout contre un petit débat, je pense qu'il y a des choses intéressantes à dire et à apprendre.

Citation:

Et que l'utilisation de l'une ou de l'autre méthode est plus un choix du programmeur selon ce qu'il préfère.

J'avais prévenu qu'on allait rentrer dans un débat idéologique :D Si un gentil modérateur pouvait diviser le sujet, ce serait effectivement très gentil de sa part !

Citation:

L'erreur saute tout de suite aux yeux

J'ai honte de dire que l'erreur ne m'a pas sauté aux yeux dans ton message précédent :oops: Il est vrai que ça se voit. L'intérêt de la méthode que je cite (je l'avais vue il y a quelque temps mais je l'ai réellement étudiée seulement aujourd'hui, je n'en suis pas encore un fanatique) est que, si tu souhaites changer le type des données pointées, alors il n'y à qu'à changer la déclaration du pointeur. Je t'accorde le fait que le compilateur warns si le pointeur dans le cast est mauvais et le coup des étoiles qui augmentent. Par exemple le code suivant compile sans warning qu'on mette ou pas l'étoile :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include<stdio.h> #include<stdlib.h> int main(void) { char **l; int k=20; l = malloc( k* sizeof(*l) ); l[0] = malloc(k * sizeof(*l)); // l ou *l, idem l[0][0]=66; printf("c = %c", l[0][0]); return 0; }
Pour ce qui est des (void*), j'avoue que je n'en utilise jamais :oops:

03/05/2012, 18h30
Neckara
C'est vrai que la méthode du :
Code:

1 2 l = malloc(k*sizeof(* l));
Évite de devoir réécrire à la main tous les malloc et les realloc si on change le type de l (ou de devoir utiliser la commande shell set pour les plus malin).

Mais en même temps, changer le type d'une variable comme cela.
Il n'y a pas que le malloc/realloc dont il faudra changer les type généralement...

C'est pour cela qu'on utilisera plutôt :
Code:

1 2 typedef int MonInt;
Comme ceci on a plus aucun problème ;)
03/05/2012, 19h25
diogene

@Bktero

Citation:

J'avais prévenu qu'on allait rentrer dans un débat idéologique...

Débat qui a lieu périodiquement sans jamais aboutir à des conclusions catégoriques, chacun ayant ses arguments, ses préférences, et s'y tenant.

Bref, à mon avis, on fait comme on le sent !
03/05/2012, 19h46
Neckara

Le problème, c'est que dans ce genre de débat, on a souvent des personnes qui tiennent absolument à imposer leur avis.

J'ai lu le débat sur le goto, en 20 pages le débat n'a pas tellement évolué, mais j'ai énormément appris et j'ai ainsi pu me forger ma propre opinion sur le sujet.

Je trouve tout de même intéressant de débattre un petit peu (dans la limite du raisonnable) ceci permet de peser le pour et le contre, de réfléchir sur un sujet et finalement, si on est de bonne volonté, d'apprendre. :D

Voici une petite réponse pour les void *
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> #include <stdlib.h> int main(void) { int k = 2; void *l; l = malloc(k * sizeof(*l)); printf("%d\n", k*sizeof(*l)); return 0; }
Citation:

neckara@NeckDebian:~$ gcc test.c -pedantic -o exe
test.c: In function ‘main’:
test.c:8: warning: invalid application of ‘sizeof’ to a void type
test.c:9: warning: invalid application of ‘sizeof’ to a void type
neckara@NeckDebian:~$ ./exe
2
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> #include <stdlib.h> int main(void) { int k = 2; void *l; l = malloc(k * sizeof(**l)); printf("%d\n", k*sizeof(**l)); return 0; }
Citation:

neckara@NeckDebian:~$ gcc test.c -pedantic -o exe
test.c: In function ‘main’:
test.c:8: error: void value not ignored as it ought to be
test.c:9: error: void value not ignored as it ought to be

Donc faire un malloc avec un (void *) allouera des élément d'un octet. Il faudra donc passer par un sizeof(type) dans ce cas là.

04/05/2012, 08h27
Bktero

Citation:

Bref, à mon avis, on fait comme on le sent !

Si même toi le dit ^^
Mais je pense qu'une fois de temps en temps, c'est pas mal de parler de sujets existentiels, avec un peu de chance ce ne seront pas toujours les mêmes participants et on pourra croiser les avis.

Citation:

Voici une petite réponse pour les void *

Les coquinous de void* !

Retour au sujet sinon ? :)
04/05/2012, 09h37
diogene

@Neckara

Citation:

Voici une petite réponse pour les void *
....
Donc faire un malloc avec un (void *) allouera des élément d'un octet.

Non, c'est une conclusion hative :

n1256 :

Citation:

6.2.5 Types
....
19 The void type comprises an empty set of values; it is an incomplete type that cannot be completed.

6.5.3.4 The sizeof operator
Constraints
1 The sizeof operator shall not be applied to an expression that has function type or an incomplete type, to the parenthesized name of such a type, or to an expression that designates a bit-field member.

4. Conformance
1 In this International Standard, ‘‘shall’’ is to be interpreted as a requirement on animplementation or on a program; conversely, ‘‘shall not’’ is to be interpreted as a prohibition.
2 If a ‘‘shall’’ or ‘‘shall not’’ requirement that appears outside of a constraint is violated, the behavior is undefined.