Como repetir uma seqüência de caracteres um número variável de vezes em C ++?

Quero inserir 'n' espaços (ou qualquer string) no início de uma string em C ++. Existe alguma maneira direta de fazer isso usando std :: strings ou char * strings?

Por exemplo, em Python, você poderia simplesmente fazer

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

No caso específico de repetir um único caractere, você pode usar std::string(size_type count, CharT ch):

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

NB. Isso não pode ser usado para repetir seqüências de vários caracteres.

Não existe uma maneira idiomática direta de repetir seqüências de caracteres em C ++ equivalentes ao operador * em Python ou ao operador x em Perl. Se você estiver repetindo um único caractere, o construtor de dois argumentos (conforme sugerido pelas respostas anteriores) funcionará bem:

std::string(5, '.')

Este é um exemplo artificial de como você pode usar um ostringstream para repetir uma string n vezes:

#include <sstream>

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

Dependendo da implementação, isso pode ser um pouco mais eficiente do que simplesmente concatenar a sequência n vezes.

Use uma das formas de string :: insert:

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

Isto irá inserir "....." (cinco pontos) no início da string (posição 0).

Sei que essa é uma pergunta antiga, mas estava procurando fazer a mesma coisa e encontrei o que considero uma solução mais simples. Parece que o cout tem essa função integrada com o cout.fill (), veja o link para uma explicação 'completa'

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

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

saídas

.....lolcat

Para efeitos de exemplo fornecido pelo OP std :: ctor da corda é suficiente: std::string(5, '.'). No entanto, se alguém estiver procurando por uma função para repetir std :: string várias vezes:

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

Como o comodoro Jaeger mencionou, não acho que nenhuma das outras respostas realmente responda a essa pergunta; a pergunta pergunta como repetir uma string, não um caractere.

Embora a resposta dada pelo Commodore esteja correta, é bastante ineficiente. Aqui está uma implementação mais rápida, a idéia é minimizar as operações de cópia e as alocações de memória aumentando primeiro exponencialmente a string:

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

Também podemos definir um operator*para obter algo mais próximo da versão do Python:

#include <utility>

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

Na minha máquina, isso é cerca de 10x mais rápido que a implementação fornecida pelo Commodore e cerca de 2x mais rápido que uma solução ingênua 'acrescentar n - 1 vezes' .

Você deve escrever seu próprio manipulador de fluxo

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

cout << multi (5) << "qualquer que seja" << "lolcat";

ITNOA

Você pode usar a função C ++ para fazer isso.

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