Discussion :

[janetx]

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 :

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

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 :

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

[Bktero]

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

Essaye avec :

Code :

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

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

Ou :

Code :

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

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

[fregolo52]

salut

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

Code :

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

Trajet* nveau= (Trajet*)malloc( sizeof(Trajet));

[Bktero]

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

[fregolo52]

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

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

[Bousk]

Oui, 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 ?

[Bktero]

Arf

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 ?

[Bktero]

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 :

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

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 à :

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

[Neckara]

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 :

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

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

[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 :

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

int *p = malloc (sizeof *p);

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

[Bktero]

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

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
#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 :

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

Espace alloue : 1600
Espace alloue : 400

[Neckara]

L'erreur saute tout de suite aux yeux :

Code :

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

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 :

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

1
2
 
l = malloc(k * sizeof(* l));

On peut déjà se retrouver dans la situation :

Code :

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

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.

[Bktero]

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 Si un gentil modérateur pouvait diviser le sujet, ce serait effectivement très gentil de sa part !

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

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

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

[Neckara]

C'est vrai que la méthode du :

Code :

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

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 :

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

1
2
 
typedef int MonInt;

Comme ceci on a plus aucun problème

[diogene]

@Bktero

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 !

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

[Neckara]

Voici une petite réponse pour les void *

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>
 
int main(void)
{
       int k = 2;
       void *l;
       l = malloc(k * sizeof(*l));
       printf("%d\n", k*sizeof(*l));
       return 0;
}

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 :

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>
 
int main(void)
{
       int k = 2;
       void *l;
       l = malloc(k * sizeof(**l));
       printf("%d\n", k*sizeof(**l));
       return 0;
}

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

[Bktero]

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.

Voici une petite réponse pour les void *

Les coquinous de void* !

Retour au sujet sinon ?

[diogene]

@Neckara

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 :

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.