Problème avec la fonction pow(les puissance)

**Clément76** · 03/10/2006, 18h46

Bonjour a tous

j'ai un petit pb avec la fonction pow pour calculer les puissances.
par exemple quand dans mon code je fais:

Code :

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

1
2
3
4
int result = 0;
result = pow(10, 2);
 
printf("%ld", result);

Sa marche
mais quand je fais:

Code :

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

1
2
 
printf("%ld", pow(10, 2));

Sa marche pas

J'arrive pas a comprendre pk et sa fais plein d'erreur dans mon programme

merci pour votre aide

**fearyourself** · 03/10/2006, 19h17

Prototype de pow :

Code :

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

       double pow(double x, double y);

Dans ton premier code, il fait un cast vers le type entier donc si le résultat est entier, tout fonctionnera (bien que tu devrais mettre %d et non %ld...)

Dans le deuxième code, aucun cast n'est fait et un compilateur correctement paramétré devrait te sortir un message de warning pour prêvenir que ce que tu donnes à printf et ce que tu lui dit sont deux choses distinctes...

Jc

**diogene** · 03/10/2006, 21h55

fearyourself

Dans le deuxième code, aucun cast n'est fait et un compilateur correctement paramétré devrait te sortir un message de warning pour prêvenir que ce que tu donnes à printf et ce que tu lui dit sont deux choses distinctes...

Je ne crois pas que les compilateurs vont jusqu'à analyser la chaîne de format pour vérifier leur concordance avec les paramètres qui sont donnés au printf. Le prototype de printf ne permet pas de telles vérifications.

**Médinoc** · 03/10/2006, 22h33

GCC le fait, utilisant une extension appelee __printflike.
La c*nnerie majeure de certaines versions (j'ignore si c'est toujours le cas), c'est qu'il accepte seulement un void* pour %p, plutôt que NimporteQuoi *...

(enfin, ça a peut-être été résolu depuis)

**Emmanuel Delahaye** · 03/10/2006, 23h01

Envoyé par diogene

fearyourself Je ne crois pas que les compilateurs vont jusqu'à analyser la chaîne de format pour vérifier leur concordance avec les paramètres qui sont donnés au printf. Le prototype de printf ne permet pas de telles vérifications.

Certains le font. Pourquoi ne le feraient-ils pas ? Sont pas plus bêtes que nous...

Pour gcc, je recommande : -Wall -Wextra -O2

Ta vie va changer !

**Emmanuel Delahaye** · 03/10/2006, 23h04

Envoyé par Médinoc

GCC le fait, utilisant une extension appelee __printflike.
La c*nnerie majeure de certaines versions (j'ignore si c'est toujours le cas), c'est qu'il accepte seulement un void* pour %p, plutôt que NimporteQuoi *...

(enfin, ça a peut-être été résolu depuis)

J'espère que non. C'est la norme. "%p" attend un void*. Point. Si ce n'est pas le cas, cast obligatoire.

Sachant que certains développeurs de gcc sont des gens du comité de normalisation, je ne m'en fais pas trop sur la comformité du gcc à la norme...

**Médinoc** · 03/10/2006, 23h29

Mais c'est débile!
En C, ça augmente les risques de cast "sauvage" de n'importe quoi en void* !

À quoi sert cette connerie?! Le type de destination n'est pas supposé agir sur la taille d'un pointeur!
(à l'inverse des anciens modifieurs comme far et near)

**Emmanuel Delahaye** · 03/10/2006, 23h35

Envoyé par Médinoc

Mais c'est débile!
En C, ça augmente les risques de cast "sauvage" de n'importe quoi en void* !

À quoi sert cette connerie?! Le type de destination n'est pas supposé agir sur la taille d'un pointeur!
(à l'inverse des anciens modifieurs comme far et near)

Ils sont peut être anciens, mais ils existent toujours (je rappelle que tout processeur x86 boot en mode reel 16-bit)

Le type par défaut des variadics est int. Si la variable n'a pas le bon type (il y a un risque avec NULL par exemple, qui peut être un int), il faut caster. Le choix s'est porté sur void * parce que c'est le plus neutre, je suppose...

Code :

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

printf ("%p\n", NULL);

Comportement indéfini.

Code :

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

printf ("%p\n", (void*) NULL);

Correct.

**Jean-Marc.Bourguet** · 04/10/2006, 09h45

Il n'y a pas de type par défaut pour les fonctions variadiques.

En fait les fonctions variadiques se comportent comme les fonctions sans prototypes. Dans ce cas, les arguments subissent les conversions suivantes:
- les valeurs des types plus petits que int sont convertis en int (ou en unsigned int si int n'est pas capable de représenter toutes les valeurs du type),
- les floats sont convertis en doubles
- les tableaux sont convertis en pointeur vers le premier élément du tableau.

Et c'est tout. Les valeurs d'autres types sont passées telles quelles. Si c'est pas la valeur attendue par la fonction, c'est un comportement indéfini.

Le problème avec les pointeurs, c'est que la norme autorise la représentation des pointeurs à différer suivant le type pointé, même la taille peut changer. En particulier, il y a eu des architectures où la représentation naturelle d'un char* prend plus de place que les autres pointeurs (elle comporte deux parties: un pointeurs vers un mot et l'indicie du caractère dans le mot, parfois aussi la taille du byte comme sur un PDP-10). La seule contrainte qu'il y ait, c'est que void* et char* doivent tout deux être capables de contenir les valeurs des autres pointeurs (mais pas nécessairement la représentation). Donc quand on passe un pointeur à une fonction sans prototype ou à une fonction variadique, il est passé tel quel. Si la fonction attends un void*, le compilateur n'en sait officiellement rien -- gcc le sait pour certaines d'entre elle et averti du problème -- et ne peut pas effectuer une conversion. (Dans la plupart des cas de nos jours, la conversion est la fonction identité.)

Le problème avec NULL, c'est que la norme autorise pas mal de types pour la valeur de NULL: tous les types entiers et void*. Dans les contextes où le type désiré est connu, il y a conversion implicite. Dans le cas des appels de fonctions sans prototype ou de fonctions variadiques, il faut convertir. Pourquoi est-ce que la norme permet plusieurs choix? Pour respecter l'existant au moment où elle a été écrite. Traditionnellement, la valeur était 0 (donc un int). Quand on s'est retrouvé avec des pointeurs sur 32 bits mais des int sur 16 bits, le code qui passait NULL à des fonctions variadiques ou sans prototype sans le convertir dans le bon type a eu des problèmes. Pour éviter les plaintes de leurs clients, certains vendeurs ont utilisé 0L comme définition pour NULL (je ne suis pas sûr que void* existait déjà, et de toute manière dans du vieux code on voit parfois utiliser NULL pour autre chose que des pointeurs) ou (void*).

**fearyourself** · 04/10/2006, 10h16

Envoyé par diogene

fearyourself Je ne crois pas que les compilateurs vont jusqu'à analyser la chaîne de format pour vérifier leur concordance avec les paramètres qui sont donnés au printf. Le prototype de printf ne permet pas de telles vérifications.

Juste pour conclure ceci avec un exemple, utilisant :

gcc version 4.0.3 (Ubuntu 4.0.3-1ubuntu5)

et le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int i=3;
    double d=4.0;
    float f = 3.2;
    float *pf = &f;
 
    printf("%f %p %d %p\n",i,d,f,pf);
    return EXIT_SUCCESS;
}

Me donne ceci :

~/tmp$ gcc -Wall -Wextra -O2 testprintf.c
testprintf.c: In function 'main':
testprintf.c:11: warning: format '%f' expects type 'double', but argument 2 has type 'int'
testprintf.c:11: warning: format '%p' expects type 'void *', but argument 3 has type 'double'
testprintf.c:11: warning: format '%d' expects type 'int', but argument 4 has type 'double'

Jc