Multiplication d'une chaîne de caractères par un nombre entier en C++.

Question

Qu'est-ce que je dois faire pour que quand je

string s = ".";

Si je le fais

cout << s * 2;

Est-ce que ce sera la même chose que

cout << "..";

?

Answer 1

Ils ne peuvent pas être multipliés mais je pense que vous pouvez écrire votre propre fonction pour le faire, quelque chose comme -

#include <iostream>
#include <string>

std::string operator*(std::string s, size_t count)
{
    std::string ret;
    for(size_t i = 0; i < count; ++i)
    {
        ret = ret + s;
    }
    return ret;
}

int main()
{
    std::string data = "+";
    std::cout << data * 10 << "\n";
}

Ce n'est probablement pas la meilleure idée, car cela sera très déroutant pour toute personne regardant le code et ne s'attendant pas à cela,

Answer 2

Vous pouvez le faire :

#include <iostream>
using namespace std;

int main()
{
    string text, new_text;
    int multiply_number;

    cin >> text >> multiply_number;

    /*
        First time in the 'for' loop:  new_text = new_text + text
                                       new_text = "" + "your text"
                                       new_text = "your text"

        Second time in the 'for' loop: new_text = new_text + text
                                       new_text = "your text" + "your text"
                                       new_text = "your textyour text"...n times
    */

    for(int i=0; i<multiply_number; i++)
    {
        new_text += text;
    }

    cout << new_text << endl;    // endl="\n"

    system("pause");
    return 0;
}

En Python, vous pouvez multiplier une chaîne comme ceci :

text = "(Your text)"
print(text*200)

Answer 3

std::string StrMultiply(const char* str, size_t count) {
        size_t stringsize = strlen(str);
        size_t buffersize = stringsize * count + 1;
        string res(buffersize,'\0');
        char* end = res._Unchecked_end();
        char* offset = res._Unchecked_begin();
        for (size_t i = 0;i < count; offset += stringsize,i++)
        {
            memcpy(offset, str, stringsize);
        }
        // mark the end
        res[buffersize - 1] = '\0';
        return res;
    }
        inline std::string operator*(std::string left, size_t right) {
            return StrMultiply(left.c_str(), right);
        }

Voici une solution respectueuse de la mémoire vive, 10 fois plus rapide que l'utilisation de stringstreams ou de string::append.