Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Constructeur de std::basic_string : répéter un caractère

Créez une chaîne contenant exactement `count` copies de `ch`. Utilisez des parenthèses pour choisir la surcharge de remplissage plutôt que celle à liste d’initialisation.

Version : ISO C++23; implementation support may vary

Syntaxe

// Constructor declaration inside std::basic_string<CharT, Traits, Allocator> (<string>)
constexpr basic_string(size_type count, CharT ch,
                       const Allocator& alloc = Allocator());

// Direct initialization of the std::string specialization
std::string padding(4, '0');

Ce constructeur de <string> crée une nouvelle chaîne qui possède count copies de ch. std::string est un alias de std::basic_string<char> : dans ce cas, ch est de type char. Si la construction réussit, size() vaut count : zéro donne une chaîne vide, et les copies de \0 comptent comme les autres éléments. Le troisième argument, facultatif, est l’allocateur. S’il est omis, Allocator() est utilisé.

Utilisez des parenthèses : std::string(4, '0') donne "0000". En revanche, std::string{4, '0'} sélectionne la surcharge à std::initializer_list<char> et stocke deux éléments : un char de valeur 4 et le caractère '0'. La surcharge distincte (const CharT*, size_type) copie les éléments de la plage fournie au lieu de répéter un caractère.

La surcharge de remplissage est constexpr depuis C++20, mais tous ses appels ne peuvent pas être des expressions constantes. size_type est non signé. Rejetez les valeurs négatives avant la conversion et imposez une limite raisonnable aux quantités issues de données non fiables. Si count dépasse max_size(), le constructeur lève std::length_error ; une allocation peut échouer même en dessous de cette limite.

Si le texte ne contient par hypothèse que des chiffres, testez d’abord length < width. Dans cette branche uniquement, créez width - length zéros et ajoutez-les à gauche. Sinon, gardez la fin avec substr(length - width). Ce test empêche tout rebouclage arithmétique non signé dans les deux soustractions. L’exemple ne vérifie pas que l’entrée contient uniquement des chiffres.

Exemples

#include <iostream>
#include <string>

std::string last_four_or_pad(const std::string& digits)
{
    constexpr std::string::size_type width = 4;
    const auto length = digits.size();

    if (length < width) {
        return std::string(width - length, '0') + digits;
    }
    return digits.substr(length - width);
}

int main()
{
    std::cout << last_four_or_pad("7") << '\n';
    std::cout << last_four_or_pad("123456") << '\n';
    std::cout << last_four_or_pad("1234") << '\n';
}

Résultat

0007
3456
1234

`7` nécessite trois zéros à gauche, `123456` conserve ses quatre derniers chiffres et `1234` reste inchangé.

Leçons associées

  • C++ · Leçon 53 · Avancé · Version : 3

Sources