Discussion :

[souviron34]

Oui, il est plus simple et plus lisible.

Et pour répondre à ta prochaine question, je fais toute confiance au compilateur pour supprimer les pointeurs intermédiaires si il le juge utile...

Seul le langage assembleur est fait pour écrire du code machine. Un langage de haut niveau (fusse-t-il le C) n'est là que pour expliquer l'intention du programmeur au compilateur. C'est le compilateur qui écrit le code machine...

Oui et ?

Code :

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

1
2
3
4
typedef struct ps {
     int ival ;
     double val ;
} mastruct ;

Je ne suis pas certain que l'ecriture :

Code :

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

1
2
3
4
5
6
7
8
static int compare (void const *a, void const *b)
{
   mastruct const *ms1 = a;
   mastruct const *ms2 = b;
 
   if ( ms1->ival > ms2->ival ) 
...
}

soit plus claire et comprehensible que :

Code :

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

1
2
3
4
5
6
7
8
static int compare (void const *a, void const *b)
{
   mastruct const *ms1 = (mastruct *)a;
   mastruct const *ms2 = (mastruct *)b;
 
   if ( ms1->ival > ms2->ival ) 
...
}

D'autant plus si la structure contient elle-meme une structure pointee par un void* qu'il faut caster...

[corrector]

Oui, c'est utile dans ce cas, si on ne peut pas faire autrement (types corrects, constantes avec . ou f )

Puisque qu'on en est à éliminer les casts au prix de variables intermédiaires :

Code :

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

1
2
3
4
double div (int a, int b) {
    double af = a;
    return af / b;
}

Je t'avoue que je ne vois pas l'avantage sur :

Code :

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

1
2
3
double div (int a, int b) {
    return (double)a / b;
}

mais : un cast en moins!

[Emmanuel Delahaye]

Puisque qu'on en est à éliminer les casts au prix de variables intermédiaires :

Code :

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

1
2
3
4
double div (int a, int b) {
    double af = a;
    return af / b;
}

un cast en moins!

Oui, pourquoi ne pas envisager cette solution...

[Médinoc]

Pour les pointeurs, par soucis de const-correctness: Quand les warnings sont activés un cast implicite ne peut pas supprimer un "const" sans que le compilo s'en aperçoive. Un cast explicite le peut.

Code :

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

1
2
3
4
5
6
7
int sortCallback(const void *pva, const void *pvb)
{
	struct uneStructure *pa = (struct uneStructure *)pva; /*pas de warning*/
	struct uneStructure *pb = (struct uneStructure *)pvb; /*pas de warning*/
 
	/* Et hop, je n'ai plus qu'à appeler des fonctions dont j'ai oublié qu'elles modifiaient l'objet...*/
}

[corrector]

Pour les pointeurs, par soucis de const-correctness:

Oui, pour les pointeurs. (D'où "static_cast" en C++.)

Mais, pour flottants, dirais-tu la même chose (voir mon exemple ci-dessus)?

[Médinoc]

J'avoue que je ne suis pas sûr. Peut-être le ferais-je par habitude, peut-être que je casterais, ou peut-être que je multiplierais simplement par 1.0 avant.

[Thierry Chappuis]

Parce que ça introduit une variable pour rien et que c'est lourd?

De toute manière, dans les deux cas, le code généré (avec -O2) est strictement identique avec mon gcc (je sais, tu as dis que tu t'en foutais!):

Code asm :

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

1
2
3
4
5
6
7
8
9
 
div:
        pushl   %ebp
        movl    %esp, %ebp
        fildl   8(%ebp)
        fildl   12(%ebp)
        popl    %ebp
        fdivrp  %st, %st(1)
        ret

Thierry

[Melem]

Je croyais que le fait que ne pas caster malloc avait un intérêt pédagogique devait clore le sujet mais visiblement ça continue. On peut mettre des cast partout si on veut mais cela signifie qu'on ne sait pas quand un cast est utile et quand il ne l'est pas mais surtout quand il est dangereux.

Cast inutile :

Code :

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

char * p = malloc(100); /* malloc retourne void *, inutile de mettre un cast */

Cast utile :

Code :

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

1
2
double A[4][4];
double * t = (double *)A;

Cast dangereux :

Code :

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

char * p = (char *)1; /* en espérant obtenir p = "1" ... */

[Thierry Chappuis]

Heu... c'était censé être ironique; ça signifie que si on persiste à ne pas utiliser le compilateur pour vérifier qu'on a déclaré les fonctions qu'on appelle, la seule alternative fiable de ne plus utiliser que des fonctions qui renvoient un pointeur, et d'utiliser cette valeur de retour pour initialiser un pointeur, comme ça on est sûr de détecter les problèmes de déclarations.

Voilà exactement ce que je voulais dire.

Je tiens à rappeler qu'en C90, c'est à priori légal d'appeler une fonction sans avoir déclaré de prototype (même si c'est une pratique horrible). Dans ce cas, le compilateur suppose que la fonction renvoit un entier de type int et ne fait aucune supposition sur le type et le nombre des arguments renvoyés.

Le compilateur n'a PAS l'obligation d'afficher un avertissement au cas ou une fonction n'est pas déclarée. Il n'a pas non plus l'obligation de proposer une option pour activer ce type d'avertissements. gcc le fait, sans doute de cl.exe le fait, mais il y a d'autre compilateurs. Par contre, en cas de conversion int vers pointeur, pour recentrer le débât le débât sur le cast de la valeur retournée par malloc() (je rapelle que c'est l'objet de ce débat. Personne ne nie que dans certains contextes, le cast est nécessaire), l'erreur de compilation est imposée (si je ne me trompe pas).

Thierry

[Thierry Chappuis]

Cast utile :

Code :

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

1
2
double A[4][4];
double * t = (double *)A;

Non! Quelle utilité? C'est justement ce genre d horreurs qu'il faut à tout prix éviter. Ca n'a aucun sens de caster un tableau de 4 tableaux de 4 double en un pointeur sur double. (Je me demande d'ailleurs si ce comportement est défini?)

Code :

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

char * p = (char *)1; /* en espérant obtenir p = "1" ... */

Clairement, comportement indéfini!

Thierry

[Thierry Chappuis]

il peut etre judicieux d'ecrire pour memoire :

Code :

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

1
2
 
p = (T *) malloc (sizeof *p * n);

pour se rememorer (surtout avec un nom de variable aussi explicite ) que c'est bien du type T*.

Miantenant, comme je le disais au debut, je m'en fiche un peu, mais c'est juste que je ne vois pas le point de le deconseiller aussi fort que cela l'est ici regulierement...

Vu comme ça, pourquoi n'écris-tu pas:

Code :

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

1
2
3
4
5
6
int n = 10;
int m;
 
/*...*/
 
m = (int) n;

Thierry

[Médinoc]

Le coup du tableau peut parfaitement se faire sans cast:

Code C :

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

1
2
double A[4][4];
double * t = &(A[0][0]);

PS: Les parenthèses sont peut-être même inutiles.

[Sve@r]

Bon, 7 pages à lire c'est énorme et je vais m'y mettre. Mais juste une petite question que je pose à ceux qui défendent avec force le cast du malloc(), est-ce qu'ils pensent aussi à caster printf() en void quand ils l'utilisent ?

Moi aussi je castais malloc à mes débuts du C. Normal, à cette époque malloc renvoyait un char* et donc je comprends cette habitude mais aujourd'hui, vu qu'il renvoie un pointeur qui colle à tout ben je me fais plus c... et pour le reste je ne caste que quand c'est nécessaire.
Mais bon, ce n'est pas pour ça que je vais aussi dire que "il ne faut pas". Les programmeurs sont de grands garçons, si certains préfèrent caster malloc en connaissance de cause ben c'est aussi leur droit. Après tout, quand le C a été écrit, sa philosophie était "le programmeur sait ce qu'il fait".

[edit]
Bon, j'ai lu les 7 pages où j'ai trouvé de bons arguments dans tous les sens. Mais je crois que la meilleure phrase est celle-ci

...en tous cas moi) ne defend pas le "pour", mais suis contre le "contre"

Ce qui, je crois, devrais réunir tout le monde. Après-tout, on est tous des programmeurs qui aimons le C (en fait moi je l'aime moins depuis que j'ai découvert Python mais c'est une autre histoire) et l'important est d'être conscient de ce qu'on fait. Si le cast existe c'est aussi pour une bonne raison, si certains veulent en mettre un peu plus qu'il n'en faut ben ils ont aussi le droit mais si d'autres n'en veulent pas ben idem.

[Melem]

C'est justement ce genre d horreurs qu'il faut à tout prix éviter. Ca n'a aucun sens de caster un tableau de 4 tableaux de 4 double en un pointeur sur double. (Je me demande d'ailleurs si ce comportement est défini?)

Ce n'est pas pour faire la dure tête mais pourrais-tu me donner une référence qui l'interdise ? Parce que je fais ça presque tous les jours ...

[Emmanuel Delahaye]

Ce n'est pas pour faire la dure tête mais pourrais-tu me donner une référence qui l'interdise ? Parce que je fais ça presque tous les jours ...

Le type est différent. D'ailleurs, le compilateur le signale si il est réglé correctement. Par contre, ceci est correct :

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
 
#include <stdio.h>
 
int main (void)
{
   double A[4][4] = {
      {1.1, 1.2, 1.3, 1.4},
      {2.1, 2.2, 2.3, 2.4},
      {3.1, 3.2, 3.3, 3.4},
      {4.1, 4.2, 4.3, 4.4},
   };
   double *t = *A;
   size_t i;
   for (i = 0; i < sizeof A / sizeof **A; i++)
   {
      printf ("%g\n", t[i]);
   }
 
   return 0;
}

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
 
1.1
1.2
1.3
1.4
2.1
2.2
2.3
2.4
3.1
3.2
3.3
3.4
4.1
4.2
4.3
4.4
 
Press ENTER to continue.

parce que le les adresses des éléments d'un tableau statique sont garanties d'être consécutives, indépendamment du nombre de dimensions.

[corrector]

Mais juste une petite question que je pose à ceux qui défendent avec force le cast du malloc(), est-ce qu'ils pensent aussi à caster printf() en void quand ils l'utilisent ?

Je n'en vois pas l'intérêt. Pour malloc, le cast peut servir pour écrire du code C qui soit aussi du C++ correct. L'argument de la documentation du code a été mentionné.

Mais pour printf? Qu'est-ce qu'un cast en void peut bien documenter? Quel avantage?

[Thierry Chappuis]

Je n'en vois pas l'intérêt. Pour malloc, le cast peut servir pour écrire du code C qui soit aussi du C++ correct. L'argument de la documentation du code a été mentionné.

Si tu décides de te limiter volontairement, pour une raison qui t'appartient, au sous-ensemble (!= C90) commun entre C et C++, c'est ton choix. Je ne comprends toutefois pas l'intérêt de compiler du code C avec un compilateur C++, étant donné qu'il est possible (avec quelques précautions) de lier un fichier objet écrit en C et compilé à l'aide d'un compilateur C à un programme C++. J'ose espérer que, pour toi, le concept de code réutilisable n'est pas synonyme de copier-coller, non?

Mais pour printf? Qu'est-ce qu'un cast en void peut bien documenter? Quel avantage?

Code :

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

(void) printf("Bonjour dvp.com!\n");

Dans la logique de ce qui a été avancé plus haut, ce code documente le fait que la valeur de retour de printf() ne nous intéresse pas.

Thierry

[Emmanuel Delahaye]

Pour malloc, le cast peut servir pour écrire du code C qui soit aussi du C++ correct.

Et ça sert à quoi ? Y'a pas un opérateur 'new' en C++ ?

Un doute m'assaille ... Tu ne veux quand même pas compiler du code C avec un compilateur C++ ? Si oui, pourquoi pas en Java ou en C#, sous prétexte que ça se ressemble... Je rappelle que le C++ n'est pas un sur-ensemble du C (alors que Objective-C est un sur-ensemble, au moins de C90).

http://david.tribble.com/text/cdiffs.htm

[Emmanuel Delahaye]

Le code en question était :

Code :

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

1
2
double A[4][4];
double * t = (double *)A;

avec le cast.

Bah pourquoi écrire du code incorrect, (oui, le cast masque silencieusement le défaut, c'est pas un scoop) alors qu'il suffit d'écrire du code correct :

Code :

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

1
2
double A[4][4];
double * t = *A;

Moins il y a de cast, mieux je me porte...

[corrector]

alors qu'il suffit d'écrire du code correct :

Code :

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

1
2
double A[4][4];
double * t = *A;

Moins il y a de cast, mieux je me porte...

Justement, ce code est-il correct (en supposant que tu utilises t pour indexer 16 éléments, pas 4)?