La bibliothèque de formatage en C++20 : Détails sur la chaîne de format

Dans mon dernier article « La bibliothèque de formatage en C++20 : la chaîne de format », j’ai présenté certaines des spécifications de format de la chaîne de format. Aujourd’hui, je termine l’essai à ce sujet.

Publicité

Dans l’article d’aujourd’hui, j’écrirai sur la largeur, la précision et le type de données de la spécification de format. Si vous souhaitez en savoir plus sur l’argument id, le remplissage, l’alignement, les signes et la forme alternative, lisez mon article précédent : « La bibliothèque de formatage en C++20 : la chaîne de format ».

Largeur et précision

Vous pouvez spécifier la largeur et la précision d’un argument. La largeur peut être appliquée aux nombres et la précision peut être appliquée aux nombres à virgule flottante et aux chaînes. Pour les nombres à virgule flottante, la précision indique la précision du formatage ; Pour les chaînes, la précision indique combien de caractères sont utilisés et comment la chaîne est finalement tronquée. Si la précision est supérieure à la longueur de la chaîne, cela n’a aucun effet sur la chaîne.

• Largeur : vous pouvez utiliser un nombre décimal positif ou un champ de remplacement ({} ou {n}) utiliser. Si spécifié, donne n la largeur minimale.
• Précision : vous pouvez utiliser un point (.) suivi d’un nombre décimal non négatif ou d’un champ de remplacement.

Quelques exemples devraient vous aider à comprendre les bases :

// formatWidthPrecision.cpp

#include 
#include 
#include 

int main() {

    int i = 123456789;
    double d = 123.456789;

    std::cout << "---" << std::format("{}", i) << "---n";
    std::cout << "---" << std::format("{:15}", i) 
      << "---n"; // (w = 15)
    std::cout << "---" << std::format("{:}", i) 
      << "---n";   // (w = 15)                             // (1)

    std::cout << 'n';

    std::cout << "---" << std::format("{}", d) << "---n";    
    std::cout << "---" << std::format("{:15}", d)
      << "---n"; // (w = 15)
    std::cout << "---" << std::format("{:}", d) 
      << "---n";   // (w = 15)

    std::cout << 'n';

    std::string s= "Only a test";

    std::cout << "---" << std::format("{:10.50}", d) 
      << "---n"; // (w = 10, p = 50)                        // (2)
    std::cout << "---" << std::format("{:{}.{}}", d, 10, 50)
      << "---n";  // (w = 10, p = 50)                       // (3)
                                      
    std::cout << "---" << std::format("{:10.5}", d) 
      << "---n";  // (w = 10, p = 5)
    std::cout << "---" << std::format("{:{}.{}}", d, 10, 5)
      << "---n";  // (w = 10,  p = 5)

    std::cout << 'n';

    std::cout << "---" << std::format("{:.500}", s) 
      << "---n";      // (p = 500)                          // (4)
    std::cout << "---" << std::format("{:.{}}", s, 500) 
      << "---n";  // (p = 500)                              // (5)
    std::cout << "---" << std::format("{:.5}", s) 
      << "---n";        // (p = 5)

}

Le w-le caractère dans le code source représente la largeur ; de même que p-Signez pour l'exactitude.

Voici quelques observations intéressantes sur le programme : Aucun espace supplémentaire n'est ajouté lorsque la largeur est spécifiée avec un champ de remplacement (1). Lorsqu'une précision supérieure à la longueur de l'affichage est utilisée double (2 et 3), la longueur de la valeur affichée reflète la précision. Cette observation ne s'applique pas à une chaîne (4 et 5).

De plus, la largeur et la précision peuvent être paramétrées.

// formatWidthPrecisionParametrized.cpp

#include 
#include 

int main() {

    std::cout << 'n';

    double doub = 123.456789;

    std::cout << std::format("{:}n", doub);  // (1)

    std::cout << 'n';

    for (auto precision: {3, 5, 7, 9}) {
       std::cout << std::format("{:.{}}n", 
                                doub,
                                precision);   // (2)
    }

    std::cout << 'n';

    int width = 10;
    for (auto precision: {3, 5, 7, 9}) {
       std::cout << std::format("{:{}.{}}n",
                                doub, 
                                width, 
                                precision);   // (3)
    }
    
    std::cout << 'n';

Le programme formatWidthPrecisionParametrized.cpp représente le double doub de différentes manières. (1) applique le paramètre par défaut. (2) la précision varie de 3 à 9. Le dernier argument de la chaîne de format va dans le {} des Formatspezifiers {:.{}}. Enfin, en (3), la largeur des valeurs doubles affichées est fixée à 10.

Type de données

Généralement, le compilateur déduit le type de valeur utilisée. Mais parfois, vous souhaitez spécifier le type de données. Voici les principaux types de données :

Cordes: s

Entiers:

• b: Format binaire
• B: Comment bmais le préfixe de base est 0B
• d: format décimal
• o: Format octal
• x: Format hexadécimales
• X: Comment xmais le préfixe de base est 0X

char et wchar_t:

• b, B, d, o, x, X: comme des entiers

booléen :

• s: true ou false
• b, B, d, o, x, X: comme des entiers

Nombres à virgule flottante:

• e: Format exponentiel
• E: Comment emais l'exposant est avec E écrit
• f, F: un point fixe; la précision est de 6
• g, G: Précision 6, mais l'exposant est à E écrit

aiguille:

• p: notation hexadécimale de son adresse

Juste les types de données void, const void et std::nullptr_t sont valides. Si vous souhaitez afficher l'adresse d'un pointeur, vous devez la saisir (const) void* convertir.

double d = 123.456789;

std::format("{}", &d);                           // ERROR
std::format("{}", static_cast(&d));       // okay
std::format("{}", static_cast(&d)); // okay
std::format("{}", nullptr);                      // okay

Avec les types de données, vous pouvez en faire un int représentez-le simplement dans un système numérique différent.

// formatType.cpp

#include 
#include 

int main() {

    int num{2020};

    std::cout << "default:     " << std::format("{:}", num)
      << 'n';
    std::cout << "decimal:     " << std::format("{:d}", num) 
      << 'n';
    std::cout << "binary:      " << std::format("{:b}", num)
      << 'n';
    std::cout << "octal:       " << std::format("{:o}", num) 
      << 'n';
    std::cout << "hexadecimal: " << std::format("{:x}", num) 
      << 'n';

}

Et après?

Jusqu'à présent, j'ai formaté les types de données élémentaires et les chaînes. Bien entendu, les types personnalisés peuvent également être formatés. Ce sera le sujet de mon prochain article.

(moi)