FAQ C++ BuilderConsultez toutes les FAQ

Pour convertir un entier en chaîne, utilisons la fonction IntToStr. Cette fonction convertit un entier en un AnsiString.

1
2
3
AnsiString Chaine; 
int i = 10; 
Chaine = IntToStr(i); // Chaine = "10"

En fonction des ordinateurs et de la configuration des options régionales, le caractère décimal par défaut n'est pas toujours le même. Si votre application est sensible à ce caractère, il est conseillé de le fixer à l'initialisation de l'application. Par exemple dans le constructeur de la fiche principale :

1
2
3
4
5
__fastcall TForm1::TForm1(TComponent* Owner) 
  : TForm(Owner) 
{ 
    DecimalSeparator = "."; 
}

1
2
3
4
5
6
7
void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key) 
{ 
    if (Key == '.' || Key == ',') 
    { 
        Key = DecimalSeparator; 
    } 
}

En C++, les types standards ne peuvent pas représenter de très grands nombres. Cela dépend bien sûr de l'implémentation. Par exemple, avec C++Builder, un entier peut être utilisé pour un nombre de 20 chiffres grand maximum (au moyen du type __int64. Consultant l'aide, on pourrait souhaiter utiliser le type double qui permet d'utiliser des nombres de 5.0 x 10^-324 à 1.7 x 10^308. Mais les calculs se font alors de manière approchée, ce qui n'est pas du tout souhaitable.

La solution est d'utiliser des librairies qui se chargent de représenter de très grands entiers. Il y en a plusieurs dont GMP, ou la librairie NTL . La librairie NTL s'est compilée sans aucun problème sous Windows avec C++Builder, ce qui n'a pas été le cas de la première. De plus, cette librairie dispose de multiples fonctions très utiles en cryptographie.

Vous pouvez également créer votre propre librairie. Le principe est donc de créer un type de grands entiers, soit une classe, cette classe contenant toutes les opérations ; donc vous devrez définir les opérateurs de base tels +, -, /, *, % sans oublier quelques fonctions très utiles telles la fonction puissance, la fonction factorielle... Pour représenter l'entier dans cette classe, vous devrez utiliser un tableau.

Pour plus d'informations, consultez les liens ci-dessous.

Pour extraire un nombre entier à partir d'un réel, vous pouvez faire appel à l'une des fonctions classiques C/C++ ou alors aux suivantes (nécessite d'inclure Math.hpp) :

int Ceil(long double X);

int Floor(long double X);

double RoundTo(const double Avalue, signed char ADigit);

double SimpleRoundTo(double Avalue, signed char ADigit);

int i = (int) 2.9; // i vaut 2

Pour transformer un réel en chaîne sans formatage particulier il suffit d'utiliser la fonction FloatToStr() :

AnsiString FloatToStr(long double Value);

1
2
3
4
float f = 12345.6789; 
ShowMessage(FloatToStrF(f, ffFixed, 8, 2)); 
ShowMessage(FormatFloat("0.00", f)); 
ShowMessage(Format("%8.2f", ARRAYOFCONST((f))));

Pour arrondir un réel, vous pouvez utiliser les fonctions SimpleRoundTo() et RoundTo() de l'unité Math (nécessite d'inclure Math.hpp). La différence se situe au niveau de l'arrondi pour les valeurs se situant à distance égale de 2 nombres : dans ce cas SimpleRoundTo() arrondit vers la valeur supérieure alors que RoundTo() vers la valeur finissant par un chiffre pair.

Exemple :

1
2
3
4
5
ShowMessage(SimpleRoundTo(3.1415, -2)); // affiche 3.14 
ShowMessage(RoundTo(3.1415, -2)); // affiche 3.14 
  
ShowMessage(SimpleRoundTo(250, 2)); // affiche 300 
ShowMessage(RoundTo(250, 2)); // affiche 200

La fonction suivante propose un tel traitement en utilisant tout simplement la fonction StrToInt :

1
2
3
4
5
6
7
8
9
10
int __fastcall HexToInt(AnsiString Value) 
{ 
   if (Value.AnsiPos("$") == 0) 
   { 
      // on ajoute $ en tête de chaîne    
      Value = "$" + Value; 
   }      
  
   return StrToInt(Value); 
}

1
2
3
ShowMessage(HexToInt("12")); // affiche 18 
ShowMessage(HexToInt("F1")); // affiche 241 
ShowMessage(HexToInt("$FF")); // affiche 255

Une première méthode :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//--------------------------------------------------------------------------- 
// IntToBinStr 
//  Number : entier ou hexadecimal non signé 
//  Digits : nombre de quartets affichés 
//--------------------------------------------------------------------------- 
AnsiString IntToBinStr(unsigned int Number, int Digits) 
{ 
    int i; 
    AnsiString KeyString; 
    char *BitSTring[] = { "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", 
                          "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"}; 
  
    if(Digits > 4 || Digits < 1) 
        return "";    // par exemple 
  
    for(i = Digits; i > 0 ; i--) 
        KeyString += BitSTring[(Number >> (4 * (i - 1))) & 0x0F]; 
  
    return KeyString; 
}

1
2
3
4
5
6
7
8
9
10
11
12
AnsiString IntToBitStr(UINT I, int nBits) 
{ 
    AnsiString N=""; 
    if(nBits > 32) nBits = 32; 
    for(int j = 0; j < nBits; j++) 
    { 
        N = "0" + N; //remplissage par le début de la chaîne 
        N[1] = (char)(N[1] + (I & 1)); // on évite un if 
        I = I / 2; // prêt pour le bit suivant 
    } 
    return N; 
}

• 19 -> 0001011
• 0x13 -> 0001011