Supprimer caractere dans une variable

Bonjour,
Voila mon probleme, j'ai une vaiable qui contiens un chiffre du type 19.5523 et je voudrais obtenir un chiffre du genre : 19.55
Comment faire pour tronquer ma variable ?
Merci d'avance.

C'est pour faire une troncature sur un nombre ou une impression avec 2 décimales?

En fait le contenu de ma variable resulte d'un calcul mathematique, ce qui me donne un chiffre a virgule que je voudrais entre guillement arrondire, je veut garder que 2 chiffres apres la virgule.

J'espere que je m'explique correctement.

Merci d'avance.

A tester : tu multiplis par 100, tu convertis en integer et tu redivises par 100.

Mais il me semble que le sujet a déja été abordé, mais j'ai pas réussi à remettre la main sur le topic ...

Je convertis en interger ?? Je ne connais pas ce mot ?

tu fais ce qu on appelle un cast, c est à dire que tu transformes le type de variable qui en float ( 1.988 ) vers une variable en int ( 1 ).

le cast, typiquement se fait ainsi:

float mavariable;
int manouvellevariable= int(mavariable);

Seulement le probleme, c est que quand tu fais çà, il y a un arrondissement de la valeur vers le plus haut. Donc

si 1.899 est casté tu peux avoir 2 à l arrivée. Le seuil du cast dépend des compilateurs

C est pour celà qu il vaut mieux en effet multiplier par 10 ou 100 , caster en int, puis rediviser.

float mavariable=1.999877

int manouvellevariable= int (mavariable*100);
puis
manouvellevariable/=100;

C est pour celà qu il vaut mieux en effet multiplier par 10 ou 100 , caster en int, puis rediviser.

Il faut rediviser par 100.0 (et pas 100) sinon le résultat est un entier. Le problème c'est que la division par 100.0 produit des résultats qui des fois contiennent de nouveau plus de 2 décimales (problème du au codage des flottants). Le problème a déjà été traité comme le dit B@tto il faudrait faire une recherche sur le forum.

OK merci bcp, j'ai compris.

Il faut rediviser par 100.0 (et pas 100) sinon le résultat est un entier.

on est bien d accord qu il s agit d une specificté Tiny C pour AVR ? Y a t il un forum dédié à ce dernier et ses spécificités?

Il faut rediviser par 100.0 (et pas 100) sinon le résultat est un entier.

on est bien d accord qu il s agit d une specificté Tiny C pour AVR ?

Pas du tout. C'est une règle du C ANSI. Si 2 opérandes sont du même type le résultat de l'opération est également de ce type.

Extrait de "The C Programming Language" de Kernighan & Ritchie (la bible du C)
When an operator has operands of different types, they are converted to a common type
according to a small number of rules.
......
Implicit arithmetic conversions work much as expected. In general, if an operator like + or *
that takes two operands (a binary operator) has operands of different types, the lower'' type is* *promoted to the higher'' type before the operation proceeds. The result is of the integer type.
*Section 6 of Appendix A states the conversion rules precisely. If there are no unsigned *
operands, however, the following informal set of rules will suffice:
? If either operand is long double, convert the other to long double.
? Otherwise, if either operand is double, convert the other to double.
? Otherwise, if either operand is float, convert the other to float.
? Otherwise, convert char and short to int.
? Then, if either operand is long, convert the other to long.

Donc dans le cas qui nous intéresse, tu prends un flottant que tu multiplies par 100. Tu le convertis en entier (pour supprimer les décimales) et tu le divises par 100. Cette division s'effectue donc sur 2 opérandes entiers et le résultat est un entier.
Si tu fais la division par 100.0 la constante est flottante et la règle citée au-dessus s'applique "promotion de l'opérande de type le plus faible" alors le résultat est bien un flottant.

En ce qui concerne la définition des constantes, il faut bien mettre le point décimal pour indiquer que la constante est un flottant, toujours dans le même bouquin:

Extrait de "The C Programming Language" de Kernighan & Ritchie
An integer constant like 1234 is an int. A long constant is written with a terminal l (ell) or L,
as in 123456789L; an integer constant too big to fit into an int will also be taken as a long.
Unsigned constants are written with a terminal u or U, and the suffix ul or UL indicates
unsigned long.
Floating-point constants contain a decimal point (123.4) or an exponent (1e-2) or both; their
type is double, unless suffixed. The suffixes f or F indicate a float constant; l or L indicate a
long double.

J'ai retrouvé ça :

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1259832451
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1276847425/6
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1270577312/8

hello... c est fou : je suis sous gcc 3.4 sous win et je fais mes casts sans soucis :

hello... c est fou : je suis sous gcc 3.4 sous win et je fais mes casts sans soucis :

Tu es certain?
Parce que moi si je fais ça:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  float a=2045.45;
  float b= (int)(a*10.0)/10;
  printf("%f arrondi a une decimale %f\n",a,b);
  system("PAUSE");      
  return 0;
}

et que je compile avec GCC v3.4.2, j'obtiens ça:

[size=13]2045.449951 arrondi a une decimale 2045.00000
Appuyez sur une touche pour continuer...[/size]

ben oui.... mingw32 ....

quand je caste, j obtiens:

float valeur=6,889;

int castis=(int)valeur;

>> castis me retourne 7