Salut,
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-ci sont
de type int.
Ce qui parfois (meme tres souvent quand il s'agit de divisions)
introduit de mauvais résultats. Comment faire pour forcer le
compilateur SANS modifier le code (par option de compilation ou
autre) à trouver le bon resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit
un resultat de 1, il fait un bond sur sa chaise :)) Et je vais pas
lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
Salut,
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-ci sont
de type int.
Ce qui parfois (meme tres souvent quand il s'agit de divisions)
introduit de mauvais résultats. Comment faire pour forcer le
compilateur SANS modifier le code (par option de compilation ou
autre) à trouver le bon resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit
un resultat de 1, il fait un bond sur sa chaise :)) Et je vais pas
lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
Salut,
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-ci sont
de type int.
Ce qui parfois (meme tres souvent quand il s'agit de divisions)
introduit de mauvais résultats. Comment faire pour forcer le
compilateur SANS modifier le code (par option de compilation ou
autre) à trouver le bon resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit
un resultat de 1, il fait un bond sur sa chaise :)) Et je vais pas
lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
Drole de vision des choses: le type du resultat d'un calcul depend des
arguments.
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Les arguments de / sont des entiers donc le resultat est entier.
Je ne vois pas pourquoi tu laisses des utilisateurs finaux non
programmeurs faire des choses sans les verifier. Faudrait donner un
peu plus de contexte pour qu'on puisse te proposer des solutions.
Drole de vision des choses: le type du resultat d'un calcul depend des
arguments.
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Les arguments de / sont des entiers donc le resultat est entier.
Je ne vois pas pourquoi tu laisses des utilisateurs finaux non
programmeurs faire des choses sans les verifier. Faudrait donner un
peu plus de contexte pour qu'on puisse te proposer des solutions.
Drole de vision des choses: le type du resultat d'un calcul depend des
arguments.
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Les arguments de / sont des entiers donc le resultat est entier.
Je ne vois pas pourquoi tu laisses des utilisateurs finaux non
programmeurs faire des choses sans les verifier. Faudrait donner un
peu plus de contexte pour qu'on puisse te proposer des solutions.
Drole de vision des choses: le type du resultat d'un calcul depend des
arguments.
Je crois pas nan...Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Les arguments de / sont des entiers donc le resultat est entier.
Non, les arguments de / ne sont pas QUE des int,
y'a des surchages !
Sinon comment veux-tu que 5.0 / 3 fonctionne...
Je ne vois pas pourquoi tu laisses des utilisateurs finaux non
programmeurs faire des choses sans les verifier. Faudrait donner
un peu plus de contexte pour qu'on puisse te proposer des
solutions.
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Il faudrait peut-etre surcharger personnellement le / et lui dire
(au compilateur) de n'appeler que le mien et pas les siens, comment
faire cela ?
Drole de vision des choses: le type du resultat d'un calcul depend des
arguments.
Je crois pas nan...
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Les arguments de / sont des entiers donc le resultat est entier.
Non, les arguments de / ne sont pas QUE des int,
y'a des surchages !
Sinon comment veux-tu que 5.0 / 3 fonctionne...
Je ne vois pas pourquoi tu laisses des utilisateurs finaux non
programmeurs faire des choses sans les verifier. Faudrait donner
un peu plus de contexte pour qu'on puisse te proposer des
solutions.
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Il faudrait peut-etre surcharger personnellement le / et lui dire
(au compilateur) de n'appeler que le mien et pas les siens, comment
faire cela ?
Drole de vision des choses: le type du resultat d'un calcul depend des
arguments.
Je crois pas nan...Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Les arguments de / sont des entiers donc le resultat est entier.
Non, les arguments de / ne sont pas QUE des int,
y'a des surchages !
Sinon comment veux-tu que 5.0 / 3 fonctionne...
Je ne vois pas pourquoi tu laisses des utilisateurs finaux non
programmeurs faire des choses sans les verifier. Faudrait donner
un peu plus de contexte pour qu'on puisse te proposer des
solutions.
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Il faudrait peut-etre surcharger personnellement le / et lui dire
(au compilateur) de n'appeler que le mien et pas les siens, comment
faire cela ?
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-c i sont
de type int. Ce qui parfois (meme tres souvent quand il s'agit de divis ions)
introduit de mauvais résultats. Comment faire pour forcer le compilat eur
SANS modifier le code (par option de compilation ou autre) à trouver le bon
resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-c i sont
de type int. Ce qui parfois (meme tres souvent quand il s'agit de divis ions)
introduit de mauvais résultats. Comment faire pour forcer le compilat eur
SANS modifier le code (par option de compilation ou autre) à trouver le bon
resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-c i sont
de type int. Ce qui parfois (meme tres souvent quand il s'agit de divis ions)
introduit de mauvais résultats. Comment faire pour forcer le compilat eur
SANS modifier le code (par option de compilation ou autre) à trouver le bon
resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Desole, 5 et 3 sont des entiers.
Sinon comment veux-tu que 5.0 / 3 fonctionne...
5.0 est un double. Il n'y a pas de surcharge de / avec un double et
un int, donc le int est converti d'abords implicitement en double. Le
resultat est un double, converti par apres implicitement en float si
tu fais
float a = 5.0/3;
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Pourquoi veux-tu qu'un "un utilisateur lambda non informaticien" entre
du code que tu ne verifies meme pas?
Les seules surcharges que tu peux definir doivent avoir au moins un
parametres n'etant pas un type de base.
A+
Desole, 5 et 3 sont des entiers.
Sinon comment veux-tu que 5.0 / 3 fonctionne...
5.0 est un double. Il n'y a pas de surcharge de / avec un double et
un int, donc le int est converti d'abords implicitement en double. Le
resultat est un double, converti par apres implicitement en float si
tu fais
float a = 5.0/3;
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Pourquoi veux-tu qu'un "un utilisateur lambda non informaticien" entre
du code que tu ne verifies meme pas?
Les seules surcharges que tu peux definir doivent avoir au moins un
parametres n'etant pas un type de base.
A+
Desole, 5 et 3 sont des entiers.
Sinon comment veux-tu que 5.0 / 3 fonctionne...
5.0 est un double. Il n'y a pas de surcharge de / avec un double et
un int, donc le int est converti d'abords implicitement en double. Le
resultat est un double, converti par apres implicitement en float si
tu fais
float a = 5.0/3;
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Pourquoi veux-tu qu'un "un utilisateur lambda non informaticien" entre
du code que tu ne verifies meme pas?
Les seules surcharges que tu peux definir doivent avoir au moins un
parametres n'etant pas un type de base.
A+
Ce que je trouve bizzare, c'est que "qqch" (le compilateur ?) devrait voir
qu'il faut transformer 5 et 3 en double pour avoir un resultat correct.
Ce que je trouve bizzare, c'est que "qqch" (le compilateur ?) devrait voir
qu'il faut transformer 5 et 3 en double pour avoir un resultat correct.
Ce que je trouve bizzare, c'est que "qqch" (le compilateur ?) devrait voir
qu'il faut transformer 5 et 3 en double pour avoir un resultat correct.
Mais dans "float a = 5;", a est un float et est egal à 5,
donc 5 est bien codé sous le format d'un float et non d'un int.
Pas d'autres solutions ?
Mais dans "float a = 5;", a est un float et est egal à 5,
donc 5 est bien codé sous le format d'un float et non d'un int.
Pas d'autres solutions ?
Mais dans "float a = 5;", a est un float et est egal à 5,
donc 5 est bien codé sous le format d'un float et non d'un int.
Pas d'autres solutions ?
Desole, 5 et 3 sont des entiers.
C'est ce que je dis, par défaut le compilateur s'il peut mettre en int il le
fait.
Mais dans "float a = 5;", a est un float et est egal à 5, donc 5 est bien
codé sous le format d'un float et non d'un int.
Sinon comment veux-tu que 5.0 / 3 fonctionne...
5.0 est un double. Il n'y a pas de surcharge de / avec un double et
un int, donc le int est converti d'abords implicitement en double. Le
resultat est un double, converti par apres implicitement en float si
tu fais
float a = 5.0/3;
Je comprend tout ça.
Ce que je trouve bizzare, c'est que "qqch" (le compilateur ?) devrait voir
qu'il faut transformer 5 et 3 en double pour avoir un resultat
correct.
Comment forcer l'apel avec les arguments de type double meme si le
compilateur veut utilisé celui avec les int ?
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Pourquoi veux-tu qu'un "un utilisateur lambda non informaticien" entre
du code que tu ne verifies meme pas?
L'appli finale permet à l'utilisateur de faire du calcul supplémentaire sur
des données.
L'utilisateur écrit son code en C++ (en général, ca se limite à des calculs
mathématiques et l'utilisation de if, for, ...)
Par analogie, Excel utilise VB pour faire ces macro, mon appli utilise le C
pour que l'utilisateur manipule ses données.
Tout le code tapé par l'utilisateur est mis dans un .CPP pour former une DLL
appelée par l'appli principale.
Et quand il tape return 5 / 3 (dans une fonction qui retourne un float); il
aimerait avoir 1.6667 et non pas 1, et je le comprends.
Dans le meme style voir que le resultat de "5 / 3 * 2.5" est différent de
2.5 * 5 / 3" est quelque peu déroutant.
Desole, 5 et 3 sont des entiers.
C'est ce que je dis, par défaut le compilateur s'il peut mettre en int il le
fait.
Mais dans "float a = 5;", a est un float et est egal à 5, donc 5 est bien
codé sous le format d'un float et non d'un int.
Sinon comment veux-tu que 5.0 / 3 fonctionne...
5.0 est un double. Il n'y a pas de surcharge de / avec un double et
un int, donc le int est converti d'abords implicitement en double. Le
resultat est un double, converti par apres implicitement en float si
tu fais
float a = 5.0/3;
Je comprend tout ça.
Ce que je trouve bizzare, c'est que "qqch" (le compilateur ?) devrait voir
qu'il faut transformer 5 et 3 en double pour avoir un resultat
correct.
Comment forcer l'apel avec les arguments de type double meme si le
compilateur veut utilisé celui avec les int ?
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Pourquoi veux-tu qu'un "un utilisateur lambda non informaticien" entre
du code que tu ne verifies meme pas?
L'appli finale permet à l'utilisateur de faire du calcul supplémentaire sur
des données.
L'utilisateur écrit son code en C++ (en général, ca se limite à des calculs
mathématiques et l'utilisation de if, for, ...)
Par analogie, Excel utilise VB pour faire ces macro, mon appli utilise le C
pour que l'utilisateur manipule ses données.
Tout le code tapé par l'utilisateur est mis dans un .CPP pour former une DLL
appelée par l'appli principale.
Et quand il tape return 5 / 3 (dans une fonction qui retourne un float); il
aimerait avoir 1.6667 et non pas 1, et je le comprends.
Dans le meme style voir que le resultat de "5 / 3 * 2.5" est différent de
2.5 * 5 / 3" est quelque peu déroutant.
Desole, 5 et 3 sont des entiers.
C'est ce que je dis, par défaut le compilateur s'il peut mettre en int il le
fait.
Mais dans "float a = 5;", a est un float et est egal à 5, donc 5 est bien
codé sous le format d'un float et non d'un int.
Sinon comment veux-tu que 5.0 / 3 fonctionne...
5.0 est un double. Il n'y a pas de surcharge de / avec un double et
un int, donc le int est converti d'abords implicitement en double. Le
resultat est un double, converti par apres implicitement en float si
tu fais
float a = 5.0/3;
Je comprend tout ça.
Ce que je trouve bizzare, c'est que "qqch" (le compilateur ?) devrait voir
qu'il faut transformer 5 et 3 en double pour avoir un resultat
correct.
Comment forcer l'apel avec les arguments de type double meme si le
compilateur veut utilisé celui avec les int ?
Je pense etre clair !
Je veux que a vaux 1.6667 quand je fais : float a = 5 / 3;
Pourquoi veux-tu qu'un "un utilisateur lambda non informaticien" entre
du code que tu ne verifies meme pas?
L'appli finale permet à l'utilisateur de faire du calcul supplémentaire sur
des données.
L'utilisateur écrit son code en C++ (en général, ca se limite à des calculs
mathématiques et l'utilisation de if, for, ...)
Par analogie, Excel utilise VB pour faire ces macro, mon appli utilise le C
pour que l'utilisateur manipule ses données.
Tout le code tapé par l'utilisateur est mis dans un .CPP pour former une DLL
appelée par l'appli principale.
Et quand il tape return 5 / 3 (dans une fonction qui retourne un float); il
aimerait avoir 1.6667 et non pas 1, et je le comprends.
Dans le meme style voir que le resultat de "5 / 3 * 2.5" est différent de
2.5 * 5 / 3" est quelque peu déroutant.
Salut,
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-ci sont
de type int. Ce qui parfois (meme tres souvent quand il s'agit de divisions)
introduit de mauvais résultats. Comment faire pour forcer le compilateur
SANS modifier le code (par option de compilation ou autre) à trouver le bon
resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Astuces pour obtenir le bon résultat :
float a = (float)5 / 3;
ou encore :
float a = 5.0 / 3;
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit un
resultat de 1, il fait un bond sur sa chaise :))
Et je vais pas lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
Comment faire pour que 5 / 3 soit égale à 1.6667 ?
- Choisir un autre langage que C++ non traité pour un langage macro
Salut,
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-ci sont
de type int. Ce qui parfois (meme tres souvent quand il s'agit de divisions)
introduit de mauvais résultats. Comment faire pour forcer le compilateur
SANS modifier le code (par option de compilation ou autre) à trouver le bon
resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Astuces pour obtenir le bon résultat :
float a = (float)5 / 3;
ou encore :
float a = 5.0 / 3;
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit un
resultat de 1, il fait un bond sur sa chaise :))
Et je vais pas lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
Comment faire pour que 5 / 3 soit égale à 1.6667 ?
- Choisir un autre langage que C++ non traité pour un langage macro
Salut,
Je sais que par défaut, quand le compilateur (à l'exécution) à besoin de
variables intermédiaires pour effectuer une ligne de calcul, celles-ci sont
de type int. Ce qui parfois (meme tres souvent quand il s'agit de divisions)
introduit de mauvais résultats. Comment faire pour forcer le compilateur
SANS modifier le code (par option de compilation ou autre) à trouver le bon
resultat ?
Ex :
float a = 5 / 3; //a vaut 1 alors qu'il devrait valoir 1.6667
Astuces pour obtenir le bon résultat :
float a = (float)5 / 3;
ou encore :
float a = 5.0 / 3;
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit un
resultat de 1, il fait un bond sur sa chaise :))
Et je vais pas lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
Comment faire pour que 5 / 3 soit égale à 1.6667 ?
- Choisir un autre langage que C++ non traité pour un langage macro
"PurL" writes:Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit
un resultat de 1, il fait un bond sur sa chaise :))
Et je vais paslui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
"PurL" <purl-nospam@chez.com> writes:
Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit
un resultat de 1, il fait un bond sur sa chaise :))
Et je vais pas
lui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)
"PurL" writes:Mais pour un utilisateur lambda, quand il rentre 5 / 3 et qui voit
un resultat de 1, il fait un bond sur sa chaise :))
Et je vais paslui dire qu'il faut mettre 5.0 pour que ca marche :) (les
utilisateurs finaux ne sont pas informaticiens)