¿Cómo repetir una cadena un número variable de veces en C ++?

Quiero insertar espacios 'n' (o cualquier cadena) al comienzo de una cadena en C ++. ¿Hay alguna forma directa de hacer esto usando std :: strings o char * strings?

Por ejemplo, en Python simplemente podrías hacer

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

En el caso particular de repetir un solo carácter, puede usar std::string(size_type count, CharT ch):

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

NÓTESE BIEN. Esto no se puede usar para repetir cadenas de caracteres múltiples.

No hay una forma idiomática directa de repetir cadenas en C ++ equivalentes al operador * en Python o al operador x en Perl. Si está repitiendo un solo carácter, el constructor de dos argumentos (como lo sugirieron las respuestas anteriores) funciona bien:

std::string(5, '.')

Este es un ejemplo artificial de cómo puede usar un ostringstream para repetir una cadena n veces:

#include <sstream>

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

Dependiendo de la implementación, esto puede ser un poco más eficiente que simplemente concatenar la cadena n veces.

Use una de las formas de string :: insert:

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

Esto insertará "....." (cinco puntos) al comienzo de la cadena (posición 0).

Sé que esta es una vieja pregunta, pero estaba buscando hacer lo mismo y he encontrado lo que creo que es una solución más simple. Parece que cout tiene esta función incorporada con cout.fill (), vea el enlace para obtener una explicación 'completa'

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

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

salidas

.....lolcat

A los efectos del ejemplo proporcionado por la OP std :: ctor de cadena es suficiente: std::string(5, '.'). Sin embargo, si alguien está buscando una función para repetir std :: string varias veces:

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

Como aludió el comodoro Jaeger, no creo que ninguna de las otras respuestas realmente responda esta pregunta; la pregunta pregunta cómo repetir una cadena, no un carácter.

Si bien la respuesta dada por Commodore es correcta, es bastante ineficiente. Aquí hay una implementación más rápida, la idea es minimizar las operaciones de copia y las asignaciones de memoria haciendo crecer primero la cadena exponencialmente:

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

También podemos definir un operator*para acercarnos a la versión de Python:

#include <utility>

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

En mi máquina, esto es aproximadamente 10 veces más rápido que la implementación dada por Commodore, y aproximadamente 2 veces más rápido que una solución ingenua de 'agregar n - 1 veces' .

Deberías escribir tu propio manipulador de flujo

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

cout << multi (5) << "lo que sea" << "lolcat";

ITNOA

Puede usar la función C ++ para hacer esto.

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