Data.FmtBcd.TBcd

• Aller au parent : Data.FmtBcd
• Méthodes
• Champs

Delphi

TBcd  = record

C++

struct DECLSPEC_DRECORD TBcd
{
public:
    System::Byte Precision;
    System::Byte SignSpecialPlaces;
    System::StaticArray<System::Byte, 32> Fraction;
    static TBcd __fastcall _op_Implicit(const System::UnicodeString str);
    static TBcd __fastcall _op_Implicit(const double d);
    static TBcd __fastcall _op_Implicit(const int I);
    static TBcd __fastcall _op_Addition(const TBcd &A, const TBcd &B);
    static TBcd __fastcall _op_Subtraction(const TBcd &A, const TBcd &B);
    static TBcd __fastcall _op_Multiply(const TBcd &A, const TBcd &B);
    static TBcd __fastcall _op_Division(const TBcd &A, const TBcd &B);
    static TBcd __fastcall _op_UnaryNegation(const TBcd &A);
    static bool __fastcall _op_Equality(const TBcd &A, const TBcd &B);
    static bool __fastcall _op_Inequality(const TBcd &A, const TBcd &B);
    static bool __fastcall _op_GreaterThan(const TBcd &A, const TBcd &B);
    static bool __fastcall _op_LessThan(const TBcd &A, const TBcd &B);
    static bool __fastcall _op_GreaterThanOrEqual(const TBcd &A, const TBcd &B);
    static bool __fastcall _op_LessThanOrEqual(const TBcd &A, const TBcd &B);
    TBcd& operator =(const System::UnicodeString str) { *this = TBcd::_op_Implicit(str); return *this; }
    TBcd& operator =(const double d) { *this = TBcd::_op_Implicit(d); return *this; }
    TBcd& operator =(const int I) { *this = TBcd::_op_Implicit(I); return *this; }
    friend TBcd operator +(const TBcd &A, const TBcd &B) { return TBcd::_op_Addition(A, B); }
    friend TBcd operator -(const TBcd &A, const TBcd &B) { return TBcd::_op_Subtraction(A, B); }
    friend TBcd operator *(const TBcd &A, const TBcd &B) { return TBcd::_op_Multiply(A, B); }
    friend TBcd operator /(const TBcd &A, const TBcd &B) { return TBcd::_op_Division(A, B); }
    TBcd operator -() { return TBcd::_op_UnaryNegation(*this); }
    friend bool operator ==(const TBcd &A, const TBcd &B) { return TBcd::_op_Equality(A, B); }
    friend bool operator !=(const TBcd &A, const TBcd &B) { return TBcd::_op_Inequality(A, B); }
    friend bool operator >(const TBcd &A, const TBcd &B) { return TBcd::_op_GreaterThan(A, B); }
    friend bool operator <(const TBcd &A, const TBcd &B) { return TBcd::_op_LessThan(A, B); }
    friend bool operator >=(const TBcd &A, const TBcd &B) { return TBcd::_op_GreaterThanOrEqual(A, B); }
    friend bool operator <=(const TBcd &A, const TBcd &B) { return TBcd::_op_LessThanOrEqual(A, B); }
};

Propriétés

Type	Visibilité	Source	Unité	Parent
record struct	public	Data.FmtBcd.pas Data.FMTBcd.hpp	Data.FmtBcd	Data.FmtBcd

Description

TBcd stocke une valeur décimale codée en binaire.

TBcd représente une valeur décimale codée en binaire. Elle contient les champs suivants :

Champ	Contenu
Précision	Nombre de chiffres dans la version décimale de la valeur.
SignSpecialPlaces	Le bit de signe (0 pour positif, toute autre valeur pour négatif) Le bit spécial (différent de zéro, indique que la valeur est vide) Le nombre de chiffres après la virgule (0 pour Précision)
Fraction	Un tableau de quartets BCD, 00 à 99 par octet, quartet de poids fort en premier. Seuls les premiers quartets Precision sont utilisés.

Vous pouvez créer un Variant qui représente une valeur TBcd à l'aide de la fonction Data.FmtBcd.VarFMTBcdCreate. De fait, la façon la plus facile de manipuler des valeurs TBcd consiste à créer des Variants pour celles-ci puis à utiliser les opérateurs intégrés fournis par le type Variant.

Voir aussi

• Routines de support BCD

• Routines de support des variants