Comment répéter une chaîne un nombre de fois variable en C ++?

Je veux insérer des espaces ‘n’ (ou n’importe quelle chaîne) au début d’une chaîne en C ++. Y at-il un moyen direct de le faire en utilisant soit std :: ssortingngs ou char * ssortingngs?

Par exemple, en Python, vous pouvez simplement faire

>>> "." * 5 + "lolcat" '.....lolcat' 

 std::ssortingng foo = std::ssortingng(5, '.') + "lolcat"; 

Découvrez les constructeurs std :: ssortingng .

Il n’y a pas de méthode idiomatique directe pour répéter des chaînes en équivalent C ++ à l’opérateur * en Python ou à l’opérateur x en Perl. Si vous répétez un seul caractère, le constructeur à deux arguments (comme suggéré par les réponses précédentes) fonctionne bien:

 std::ssortingng(5, '.') 

Ceci est un exemple artificiel de la façon dont vous pourriez utiliser un ossortingngstream pour répéter une chaîne n fois:

 #include  std::ssortingng repeat(int n) { std::ossortingngstream os; for(int i = 0; i < n; i++) os << "repeat"; return os.str(); } 

Selon l'implémentation, cela peut être légèrement plus efficace que la simple concaténation de la chaîne n fois.

Utilisez l’une des formes de chaîne :: insert:

 std::ssortingng str("lolcat"); str.insert(0, 5, '.'); 

Cela va insérer “…..” (cinq points) au début de la chaîne (position 0).

Je sais que c’est une vieille question, mais je cherchais à faire la même chose et à trouver ce que je pense être une solution plus simple. Il semble que cout ait cette fonction intégrée à cout.fill (), voir le lien pour une explication complète

http://www.java-samples.com/showtutorial.php?tutorialid=458

 cout.width(11); cout.fill('.'); cout < < "lolcat" << endl; 

les sorties

 .....lolcat 

Comme l’a mentionné le commodore Jaeger, je ne pense pas que l’une des autres réponses réponde réellement à cette question; la question demande comment répéter une chaîne, pas un caractère.

Bien que la réponse donnée par Commodore soit correcte, elle est plutôt inefficace. Voici une implémentation plus rapide, l’idée est de minimiser les opérations de copie et les allocations de mémoire en augmentant d’abord de manière exponentielle la chaîne:

 #include  #include  std::ssortingng repeat(std::ssortingng str, const std::size_t n) { if (n == 0) { str.clear(); str.shrink_to_fit(); return str; } else if (n == 1 || str.empty()) { return str; } const auto period = str.size(); if (period == 1) { str.append(n - 1, str.front()); return str; } str.reserve(period * n); std::size_t m {2}; for (; m < n; m *= 2) str += str; str.append(str.c_str(), (n - (m / 2)) * period); return str; } 

Nous pouvons également définir un operator* pour obtenir quelque chose de plus proche de la version de Python:

 #include  std::ssortingng operator*(std::ssortingng str, std::size_t n) { return repeat(std::move(str), n); } 

Sur ma machine, cela est environ 10 fois plus rapide que l'implémentation de Commodore, et environ 2 fois plus rapide qu'une solution naïve «append n - 1 fois» .

Vous devriez écrire votre propre manipulateur de stream

cout < < multi (5) << "quelle que soit" << "lolcat";

ITNOA

Vous pouvez utiliser la fonction C ++ pour ce faire.

  std::ssortingng repeat(const std::ssortingng& input, size_t num) { std::ossortingngstream os; std::fill_n(std::ostream_iterator(os), num, input); return os.str(); } 

Aux fins de l’exemple fourni par l’OP std :: ssortingng, le ctor est suffisant: std::ssortingng(5, '.') . Cependant, si quelqu’un cherche une fonction pour répéter std :: ssortingng plusieurs fois:

 std::ssortingng repeat(const std::ssortingng& input, unsigned num) { std::ssortingng ret; ret.reserve(input.size() * num); while (num--) ret += input; return ret; }