Wie kann man einen String in C ++ eine variable Anzahl von Malen 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 mit std :: strings oder char * strings zu tun?

ZB in Python könnte man das einfach machen

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

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

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

NB. Dies kann nicht zum Wiederholen von Zeichenfolgen mit mehreren Zeichen verwendet werden.

Es gibt keine direkte idiomatische Möglichkeit, Zeichenfolgen in C ++ zu wiederholen, die dem Operator * in Python oder dem Operator x in Perl entsprechen. 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önnen, um einen String 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();
}

Abhängig von der Implementierung kann dies etwas effizienter sein, als die Zeichenfolge n-mal einfach zu verketten.

Verwenden Sie eine der Formen von string :: insert:

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

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

Ich weiß, dass dies eine alte Frage ist, aber ich wollte das Gleiche tun und habe eine meiner Meinung nach einfachere Lösung gefunden. Es scheint, dass cout diese Funktion mit cout.fill () integriert hat. Eine vollständige Erklärung finden Sie unter dem Link

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 reicht der ctor von std :: string aus : std::string(5, '.'). Wenn jedoch jemand nach einer Funktion sucht, mit der std :: string mehrmals wiederholt werden kann:

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; In der Frage wird gefragt, wie eine Zeichenfolge und kein Zeichen wiederholt werden soll.

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 ein 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 meinem Computer ist dies ungefähr 10x schneller als die von Commodore bereitgestellte Implementierung und ungefähr 2x schneller als eine naive Lösung, die n-1-mal anhängt.

Sie sollten Ihren eigenen Stream-Manipulator schreiben

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

cout << multi (5) << "was auch immer" << "lolcat";

ITNOA

Sie können dazu die C ++ - Funktion verwenden.

 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();
 }