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

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

Par exemple, en Python, vous pouvez simplement faire

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

Dans le cas particulier de la répétition d'un seul caractère, vous pouvez utiliser std::string(size_type count, CharT ch):

std::string(5, '.') + "lolcat"

NB. Cela ne peut pas être utilisé pour répéter des chaînes à plusieurs caractères.

Il n'y a pas de moyen idiomatique direct pour répéter des chaînes en C ++ équivalent à 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::string(5, '.')

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

#include <sstream>

std::string repeat(int n) {
    std::ostringstream 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 de simplement concaténer la chaîne n fois.

Utilisez l'une des formes de string :: insert:

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

Cela insérera "....." (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 j'ai trouvé ce que je pense être une solution plus simple. Il semble que cout ait cette fonction intégrée avec 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

Aux fins de l'exemple fourni par l'OP std :: La cteur de chaîne est suffisante: std::string(5, '.'). Cependant, si quelqu'un cherche une fonction pour répéter std :: string plusieurs fois:

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

Comme le commodore Jaeger y a fait allusion, je ne pense pas qu'aucune des autres réponses ne 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 tout à fait 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 exponentiellement la chaîne:

#include <string>
#include <cstddef>

std::string repeat(std::string 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 se rapprocher de la version Python:

#include <utility>

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

Sur ma machine, c'est environ 10 fois plus rapide que l'implémentation donnée par Commodore, et environ 2 fois plus rapide qu'une solution naïve «ajouter n - 1 fois» .

Vous devriez écrire votre propre manipulateur de flux

• http://www.two-sdg.demon.co.uk/curbralan/papers/WritingStreamManipulators.html

cout << multi (5) << "peu importe" << "lolcat";

ITNOA

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

 std::string repeat(const std::string& input, size_t num)
 {
    std::ostringstream os;
    std::fill_n(std::ostream_iterator<std::string>(os), num, input);
    return os.str();
 }