J'aimerais mettre un float dans un int, est-ce possible ? sachat que le float n'a rien apres la virgule, lorsque je fait ca, la valeur n'est pas la bonne  
 
conversion = (utilisateur.valeurTotale - tarif)*100 ;
rendre = int (conversion) ;
 
Conversion est un float tout comme utilisateur.valeurTotale et tarif, rendre lui est entier. Lorsque conversion vaut 92 par exemple, rendre vaut 91 !! Vous savez d'ou ca vient et comment le resoudre ??
 
Merci d'avance

problème d'arrondi.
http://cplusplus.com/ref/cmath/

J'en doute pas mais j'ai regardé et je vois pas comment faire !
 
(utilisateur.valeurTotale - tarif) vaut 1,92 par exemple, donc *100 ca donne 192. je l'ai affiché c'est bon c'est bien ca, mais la ligne "rendre = int (conversion)" m'affiche 191
please help

et pourquoi tu as effacé l'autre topic???

je me suis chier je voulais le modifier pour eviter d'en ouvrir un autre et je le trouve plus apparement j'ai du cliquer sur le bouton effacer au lieu de valider j'en suis desolé

cheetwoox, regarde ça, compile le, et réfléchis bien à ton problème:

 
Edit: je suis une merde, j'avais collé la mauvaise version .
 

desolé je doit etre stupide je vois pas ce que je doit modifier pour que ca marche le tiens c'est 0.919 donc normal *100 ca donne 91 ou 92 suivant si t'arrondi mais le mien c'est 1,92 si tu fait *100 ca fait 192 y'a rien a arrondir ? (c'aurait ete different si j'avais mis 1,919)
sauvez moi de la decheance

tu fais +0,1 avant de le transformer en int

serieux ? si oui je le fait mais bon...

Si tu es sûr que ton nombre n'a pas de décimales, le +0,1 donnera tous des nombres finissant par ",1" (ou ",099999" pour ceux qui foiraient dans le cas précédent).
Dans tous les cas ils seront OK une fois tronqués en int.  
C'est peut-être pas très propre, mais c'est une solution facile à ton problème

C'est un classique... Il faut prendre floor(fValue * 100.0 + 0.5) (et pas 0.1) afin de convertir ton nombre à l'entier le plus proche.
floor(1.920*100 + 0.5) = floor(192.5) = 192
floor(1.921*100 + 0.5) = floor(192.6) = 192
floor(1.922*100 + 0.5) = floor(192.7) = 192
floor(1.923*100 + 0.5) = floor(192.8) = 192
floor(1.924*100 + 0.5) = floor(192.9) = 192
floor(1.925*100 + 0.5) = floor(193.0) = 193
floor(1.926*100 + 0.5) = floor(193.1) = 193
floor(1.927*100 + 0.5) = floor(193.2) = 193
floor(1.928*100 + 0.5) = floor(193.3) = 193
floor(1.929*100 + 0.5) = floor(193.4) = 193

 
ouais mais ici comme il était sûr que ses nombres étaient sans partie décimale... enfin c'est vrai qu'on peut d'office mettre ,5

oui mais maintenant avec le floor quant ca vaut 1,92 je me retrouve avec 191

C'est toi qui met la valeur à 1,92, ou bien elle est calculée ? Et combien de décimales tu affiches ? tu peux nous montrer ton code ?  

vous riez pas si je copie colle le code complet parceque c'est vraiement honteux pour quelqu'un qui a fait deux ans de prog en dut info ^^
bah ca fait longtemps donc je sais plus trop programmer, c'est une caisse automatique, je lui rentre le fond de caisse, un prix, ensuite on paye avec les pieces qu'on veut et elle calcule le rendu de monnaie suivant les pieces disponibles.
 
//----------------------------//
// Liaisons de bibliothèques  //
//----------------------------//
 
#include <iostream>
#include <cmath>
using namespace std;
 
 
//----------------------------//
// Déclaration des variables  //
//----------------------------//
 
/* Déclaration d'un type enregistrement contenant le nombre de pieces
   et la valeur representee par ces pieces */
   struct monnaie
   {
         int unCentime ;
         int deuxCentime ;
         int cinqCentime ;
         int dixCentime ;
         int vingtCentime ;
         int cinquanteCentime ;
         int unEuro ;
         int deuxEuro ;
         float valeurTotale ;
   } ;
 
 
//----------------------------------//
//    En-tetes de sous programme    //
//----------------------------------//
 
/* Calcule la valeur totale en fonction du nombre de pièces et prend en entrée
   le contenu de la structure e */
void calculTotal (struct monnaie & e) ;
 
 
//----------------------------//
//    Programme principal     //
//----------------------------//
 
void main()
{
 
     //----------------------------//
     // Déclaration des variables  //
     //----------------------------//
 
     /* Déclaration d'un type flottant contenant le tarif à payer demandé
        par la machine ainsi qu'un flottant contenant le somme à rendre */
     float tarif, conversion, y ;
 
     /* Déclaration des types entier contenant le nombre de pieces d'un type
     donné et à leur valeur */
     int nombre, valeur, rendre, x ;
 
 
     //----------------------------//
     //  Définition des variables  //
     //----------------------------//
 
     /* Définition des variables enregistrement qui contienent la quantité de
        pièces de 1,2,5,10,20 et 50 centimes et 1 et 2 euros étant à l'origine
        dans la caisse et celles donée par l'utilisateur */
     monnaie caisse, utilisateur ;
 
 
     //------------------------------//
     // Initialisation des variables //
     //------------------------------//
 
     utilisateur.unCentime = 0 ;
     utilisateur.deuxCentime = 0 ;
     utilisateur.cinqCentime = 0 ;
     utilisateur.dixCentime = 0 ;
     utilisateur.vingtCentime = 0 ;
     utilisateur.cinquanteCentime = 0 ;
     utilisateur.unEuro = 0 ;
     utilisateur.deuxEuro = 0 ;
 
 
     //----------------------------//
     //   Traitement principal     //
     //----------------------------//
 
     /* Afin de tester le programme, on fournit le contenu de la caisse
        automatique */
     cout << "Entrez le nombre de pieces de 1 centime d'euro dont dispose la machine :" << endl ;
     cin >> caisse.unCentime ;
     cout << "Entrez le nombre de pieces de 2 centime d'euro dont dispose la machine :" << endl ;
     cin >> caisse.deuxCentime ;
     cout << "Entrez le nombre de pieces de 5 centime d'euro dont dispose la machine :" << endl ;
     cin >> caisse.cinqCentime ;
     cout << "Entrez le nombre de pieces de 10 centime d'euro dont dispose la machine :" << endl ;
     cin >> caisse.dixCentime ;
     cout << "Entrez le nombre de pieces de 20 centime d'euro dont dispose la machine :" << endl ;
     cin >> caisse.vingtCentime ;
     cout << "Entrez le nombre de pieces de 50 centime d'euro dont dispose la machine :" << endl ;
     cin >> caisse.cinquanteCentime ;
     cout << "Entrez le nombre de pieces de 1 euro dont dispose la machine :" << endl ;
     cin >> caisse.unEuro ;
     cout << "Entrez le nombre de pieces de 2 euro dont dispose la machine :" << endl ;
     cin >> caisse.deuxEuro ;
 
     /* Afin de tester le programme, on fournit ensuite prix à payer */
     cout << "Entrez le prix a payer :" << endl ;
     cin >> tarif ;
 
     /* Boucle d'entrée de l'argent en caisse tant que la somme donée est
        inferieure a celle demandée*/
     for (utilisateur.valeurTotale = 0.0; utilisateur.valeurTotale < tarif
     {
 
            /* On fournit ensuite le paiement de la somme demandée de la facon que
               l'on veut en entrant le nombre de pièce de chaque type */
            cout << "Entrez la valeur des pieces que vous souhaitez inserer (valeur en centimes, ex : 1, 2, 10, 100...) :" << endl ;
            cin >> valeur ;
            cout << "Entrez le nombre de pieces de cette valeur que vous inserez :" << endl ;
            cin >> nombre ;
 
            switch (valeur)
            {
                case 1 : utilisateur.unCentime = utilisateur.unCentime + nombre ; break;
                case 2 : utilisateur.deuxCentime = utilisateur.deuxCentime + nombre ; break;
                case 5 : utilisateur.cinqCentime = utilisateur.cinqCentime + nombre ; break;
                case 10 : utilisateur.dixCentime = utilisateur.dixCentime + nombre ; break;
                case 20 : utilisateur.vingtCentime = utilisateur.vingtCentime + nombre ; break;
                case 50 : utilisateur.cinquanteCentime = utilisateur.cinquanteCentime + nombre ; break;
                case 100 : utilisateur.unEuro = utilisateur.unEuro + nombre ; break;
                case 200 : utilisateur.deuxEuro = utilisateur.deuxEuro + nombre ; break;
                default : cout << "Cette valeur de piece n'existe pas, veuillez reessayer !" << endl ;
            }
            calculTotal (utilisateur) ;
            cout << "Vous avez fournit :" << utilisateur.valeurTotale << "Euro" << endl ;
 
     }
 
     /* Systeme de rendu de monnaie */
     if (utilisateur.valeurTotale == tarif)
     {
         cout << "Merci d'avoir fournit l'appoint. A bientot !" << endl ;
     }
     else
     {
         /* Mise a jour du contenu de la caisse */
         caisse.unCentime = caisse.unCentime + utilisateur.unCentime ;
         caisse.deuxCentime = caisse.deuxCentime + utilisateur.deuxCentime ;
         caisse.cinqCentime = caisse.cinqCentime + utilisateur.cinqCentime ;
         caisse.dixCentime = caisse.dixCentime + utilisateur.dixCentime ;
         caisse.vingtCentime = caisse.vingtCentime + utilisateur.vingtCentime ;
         caisse.cinquanteCentime = caisse.cinquanteCentime + utilisateur.cinquanteCentime ;
         caisse.unEuro = caisse.unEuro + utilisateur.unEuro ;
         caisse.deuxEuro = caisse.deuxEuro + utilisateur.deuxEuro ;
 
         /* Somme à rendre à l'utilisateur */
         conversion = ((utilisateur.valeurTotale - tarif)*100)-0,5 ;
         conversion = floor (conversion) ;
         cout << conversion << endl ;
         rendre = (int (conversion)) ;
         cout << rendre << endl ;
 
         //------------------------------------------------//
         /* Calcul des pieces à rendre selon disponibilité */
         //------------------------------------------------//
 
         /* Pièces de 2 Euro */
         x = rendre/200 ;
         y = 0.0 ;
         if (caisse.deuxEuro >= x)
         {
             cout << "Rendu en pieces de 2 Euro : " << x << " pieces : " << x*2 << "Euro" << endl ;
             y = y + (x*2) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.deuxEuro = caisse.deuxEuro - x ;
             rendre = rendre - (x*200) ;
         }
         else
         {
             cout << "Rendu en pieces de 2 Euro : " << caisse.deuxEuro << " pieces : " << caisse.deuxEuro*2 << "Euro" << endl ;
             caisse.deuxEuro = 0 ;
             rendre = rendre - (caisse.deuxEuro*200) ;
         }
 
         /* Pièces de 1 Euro */
         x = rendre/100 ;
         if (caisse.unEuro >= x)
         {
             cout << "Rendu en pieces de 1 Euro : " << x << " pieces : " << x*1 << "Euro" << endl ;
             y = y + (x*1) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.unEuro = caisse.unEuro - x ;
             rendre = rendre - (x*100) ;
         }
         else
         {
             cout << "Rendu en pieces de 1 Euro : " << caisse.unEuro << " pieces : " << caisse.unEuro*1 << "Euro" << endl ;
             caisse.unEuro = 0 ;
             rendre = rendre - (caisse.unEuro*100) ;
         }
 
         /* Pièces de 0,5 Euro */
         x = rendre/50 ;
         if (caisse.cinquanteCentime >= x)
         {
             cout << "Rendu en pieces de 50 centimes : " << x << " pieces : " << x*0.5 << "Euro" << endl ;
             y = y + (x*0.5) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.cinquanteCentime = caisse.cinquanteCentime - x ;
             rendre = rendre - (x*50) ;
         }
         else
         {
             cout << "Rendu en pieces de 50 centimes : " << caisse.cinquanteCentime << " pieces : " << caisse.cinquanteCentime*0.5 << "Euro" << endl ;
             caisse.cinquanteCentime = 0 ;
             rendre = rendre - (caisse.cinquanteCentime*50) ;
         }
 
         /* Pièces de 0,2 Euro */
         x = rendre/20 ;
         if (caisse.vingtCentime >= x)
         {
             cout << "Rendu en pieces de 20 centimes : " << x << " pieces : " << x*0.2 << "Euro" << endl ;
             y = y + (x*0.2) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.vingtCentime = caisse.vingtCentime - x ;
             rendre = rendre - (x*20) ;
         }
         else
         {
             cout << "Rendu en pieces de 20 centimes : " << caisse.vingtCentime << " pieces : " << caisse.vingtCentime*0.2 << "Euro" << endl ;
             caisse.vingtCentime = 0 ;
             rendre = rendre - (caisse.vingtCentime*20) ;
         }
 
         /* Pièces de 0,1 Euro */
         x = rendre/10 ;
         if (caisse.dixCentime >= x)
         {
             cout << "Rendu en pieces de 10 centimes : " << x << " pieces : " << x*0.1 << "Euro" << endl ;
             y = y + (x*0.1) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.dixCentime = caisse.dixCentime - x ;
             rendre = rendre - (x*10) ;
         }
         else
         {
             cout << "Rendu en pieces de 10 centimes : " << caisse.dixCentime << " pieces : " << caisse.dixCentime*0.1 << "Euro" << endl ;
             caisse.dixCentime = 0 ;
             rendre = rendre - (caisse.dixCentime*10) ;
         }
 
         /* Pièces de 0,05 Euro */
         x = rendre/5 ;
         if (caisse.cinqCentime >= x)
         {
             cout << "Rendu en pieces de 5 centimes : " << x << " pieces : " << x*0.05 << "Euro" << endl ;
             y = y + (x*0.05) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.cinqCentime = caisse.cinqCentime - x ;
             rendre = rendre - (x*5) ;
         }
         else
         {
             cout << "Rendu en pieces de 5 centimes : " << caisse.cinqCentime << " pieces : " << caisse.cinqCentime*0.05 << "Euro" << endl ;
             caisse.cinqCentime = 0 ;
             rendre = rendre - (caisse.cinqCentime*5) ;
         }
 
         /* Pièces de 0,02 Euro */
         x = rendre/2 ;
         if (caisse.deuxCentime >= x)
         {
             cout << "Rendu en pieces de 2 centimes : " << x << " pieces : " << x*0.02 << "Euro" << endl ;
             y = y + (x*0.02) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.deuxCentime = caisse.deuxCentime - x ;
             rendre = rendre - (x*2) ;
         }
         else
         {
             cout << "Rendu en pieces de 2 centimes : " << caisse.deuxCentime << " pieces : " << caisse.deuxCentime*0.02 << "Euro" << endl ;
             caisse.deuxCentime = 0 ;
             rendre = rendre - (caisse.deuxCentime*2) ;
         }
 
         /* Pièces de 0,01 Euro */
         x = rendre/1 ;
         if (caisse.unCentime >= x)
         {
             cout << "Rendu en pieces de 1 centimes : " << x << " pieces : " << x*0.01 << "Euro" << endl ;
             y = y + (x*0.01) ;
             cout << "Rendu jusqu'a present : " << y << endl ;
             caisse.unCentime = caisse.unCentime - x ;
             rendre = rendre - (x*1) ;
         }
         else
         {
             cout << "Rendu en pieces de 1 centimes : " << caisse.unCentime << " pieces : " << caisse.unCentime*0.01 << "Euro" << endl ;
             caisse.unCentime = 0 ;
             rendre = rendre - (caisse.unCentime*1) ;
         }
 
     }
 
     /* Pour garder le shell ouvert */
     cin >> valeur ;
}
 
 
//----------------------------------//
//    Corps des sous-programmes     //
//----------------------------------//
 
/* Calcule la valeur totale en fonction du nombre de pièces */
void calculTotal (struct monnaie & e)
{
     e.valeurTotale = (e.unCentime*0.01)+(e.deuxCentime*0.02)+
                            (e.cinqCentime*0.05)+(e.dixCentime*0.10)+
                            (e.vingtCentime*0.20)+(e.cinquanteCentime*0.50)+
                            (e.unEuro*1.00)+(e.deuxEuro*2.00) ;
}

voila si vous pigez rien c'est normal c'est mes explications qui sont pourries, je repondrait aux questions demain si vous en avez la je vais dodo

oh du C

C'est +0.5 et pas -0.5 !  
Avec ton code c'est normal que floor(1.92*100-0.5) = floor(191.5) = 191.
 
         /* Somme à rendre à l'utilisateur */  
         conversion = ((utilisateur.valeurTotale - tarif)*100)-0,5 ;  
         conversion = floor (conversion) ;

oui mais c'est moi qui ai mis - pour voir si ca changeait quelque chose, met + et compile et tu verra ca marche pas

T'as pas essayé * / et % ?

#include "stdafx.h"
#include <iostream>  
#include <cmath>  
using namespace std;  
 
int main(int argc, char* argv[])
{
 float conversion;
 int rendre;
 
 conversion = 1.92 * 100 + 0.5;
 conversion = floor(conversion);
 rendre = int (conversion);  
 
 cout << "rendre = " << rendre << endl ;  
 cout << "conversion = " << conversion << endl ;
 
 return 0;
}
 
à l'exécution cela donne bien :
 
rendre = 192
conversion = 192
 
Le probème est que tu fais bien le boulot d'arrondi avec ton float "conversion" mais que tu gaches tout en appelant int() pour le convertir en integer. Essaye avec mon exemple ci-dessus puis avec :
 
rendre = floor(1.92 * 100 + 0.5);
 

merci je vais tester ca

oki le dernier truc marche maintenant merci beaucoup a tous !