Wie kann ich eine Zeichenfolge in C++ beliebig oft wiederholen?

Ich möchte ‘n’ Leerzeichen (oder eine beliebige Zeichenfolge) am Anfang einer Zeichenfolge in C++ einfügen. Gibt es eine direkte Möglichkeit, dies entweder mit std::strings oder char*-Strings zu tun?

In Python könnten Sie zB einfach tun

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

Im besonderen Fall der Wiederholung eines einzelnen Zeichens können Sie verwenden std::string(size_type count, CharT ch):

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

Dies kann nicht verwendet werden, um Zeichenfolgen mit mehreren Zeichen zu wiederholen.

Es gibt keine direkte idiomatische Möglichkeit, Zeichenfolgen in C++ zu wiederholen, die dem entsprechen * Operator in Python oder der x Operator in Perl. Wenn Sie ein einzelnes Zeichen wiederholen, funktioniert der Konstruktor mit zwei Argumenten (wie in den vorherigen Antworten vorgeschlagen) gut:

std::string(5, '.')

Dies ist ein erfundenes Beispiel dafür, wie Sie einen ostringstream verwenden könnten, um eine Zeichenfolge n-mal zu wiederholen:

#include <sstream>

std::string repeat(int n) {
    std::ostringstream os;
    for(int i = 0; i < n; i++)
        os << "repeat";
    return os.str();
}

Je nach Implementierung kann dies etwas effizienter sein, als die Zeichenfolge einfach n-mal zu verketten.

Verwenden Sie eine der Formen von string::insert:

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

Dadurch wird “…..” (fünf Punkte) am Anfang der Zeichenfolge (Position 0) eingefügt.

Ich weiß, dass dies eine alte Frage ist, aber ich wollte dasselbe tun und habe eine meiner Meinung nach einfachere Lösung gefunden. Es scheint, dass cout diese Funktion in cout.fill() integriert hat, siehe den Link für eine “vollständige” Erklärung

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

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

Ausgänge

.....lolcat

Für die Zwecke des vom OP bereitgestellten Beispiels ist der ctor von std::string ausreichend: std::string(5, '.'). Wenn jedoch jemand nach einer Funktion sucht, um std::string mehrmals zu wiederholen:

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

Wie Commodore Jaeger anspielte, glaube ich nicht, dass eine der anderen Antworten diese Frage tatsächlich beantwortet. Die Frage fragt, wie man eine Zeichenfolge wiederholt, nicht ein Zeichen.

Die Antwort von Commodore ist zwar richtig, aber ziemlich ineffizient. Hier ist eine schnellere Implementierung, die Idee ist, Kopiervorgänge und Speicherzuweisungen zu minimieren, indem zuerst die Zeichenfolge exponentiell vergrößert wird:

#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;
}

Wir können auch an definieren operator* um der Python-Version etwas näher zu kommen:

#include <utility>

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

Auf meiner Maschine ist dies etwa 10x schneller als die Implementierung von Commodore und etwa 2x schneller als eine naive ‘n – 1 Mal anhängen’ Lösung.

Sie sollten Ihren eigenen Stream-Manipulator schreiben

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

cout << multi(5) << "whatever" << "lolcat";