Najprostszym sposobem na konwersję int na string w C ++

Jaki jest najłatwiejszy sposób konwersji z intodpowiednika stringw C ++. Mam świadomość dwóch metod. Czy jest jakiś łatwiejszy sposób?

(1)

int a = 10;
char *intStr = itoa(a);
string str = string(intStr);

(2)

int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

C ++ 11 wprowadza się std::stoi(i warianty dla każdego typu) i numerycznych std::to_string, odpowiedniki C atoii itoa, ale wyrażone w perspektywiestd::string .

#include <string> 

std::string s = std::to_string(42);

jest zatem najkrótszym sposobem, jaki mogę wymyślić. Możesz nawet pominąć nazywanie typu za pomocąauto słowa kluczowego:

auto s = std::to_string(42);

Uwaga: patrz [string.conversions] ( 21.5 w n3242 )

Rozpoczynając dyskusję z @ v.oddou kilka lat później, C ++ 17 w końcu zapewnił sposób na wykonanie pierwotnie opartego na makro rozwiązania typu agnostyk (zachowane poniżej) bez przechodzenia przez brzydotę makro.

// variadic template
template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    // fold expression
    ( sstr << std::dec << ... << args );
    return sstr.str();
}

Stosowanie:

int i = 42;
std::string s = sstr( "i is: ", i );
puts( sstr( i ).c_str() );

Foo x( 42 );
throw std::runtime_error( sstr( "Foo is '", x, "', i is ", i ) );

Oryginalna odpowiedź:

Ponieważ „konwersja ... na ciąg” jest powtarzającym się problemem, zawsze definiuję makro SSTR () w centralnym nagłówku moich źródeł C ++:

#include <sstream>

#define SSTR( x ) static_cast< std::ostringstream & >( \
        ( std::ostringstream() << std::dec << x ) ).str()

Użycie jest tak proste, jak mogłoby być:

int i = 42;
std::string s = SSTR( "i is: " << i );
puts( SSTR( i ).c_str() );

Foo x( 42 );
throw std::runtime_error( SSTR( "Foo is '" << x << "', i is " << i ) );

Powyższe jest kompatybilne z C ++ 98 (jeśli nie możesz używać C ++ 11 std::to_string) i nie wymaga żadnych zewnętrznych programów (jeśli nie możesz użyć Boost lexical_cast<>); oba te rozwiązania mają jednak lepszą wydajność.

Zwykle używam następującej metody:

#include <sstream>

template <typename T>
  std::string NumberToString ( T Number )
  {
     std::ostringstream ss;
     ss << Number;
     return ss.str();
  }

Jest to szczegółowo opisane tutaj .

Prawdopodobnie najczęstszym łatwym sposobem jest zawijanie drugiego wyboru w szablonie o nazwie lexical_cast, takim jak ten w Boost , więc twój kod wygląda następująco:

int a = 10;
string s = lexical_cast<string>(a);

Jedną z zalet tego jest to, że obsługuje również inne obsady (np. Działa również w przeciwnym kierunku).

Zauważ też, że chociaż Boost lexical_cast zaczynał jako pisanie do strumienia tekstowego, a następnie wypakowywanie go ze strumienia, teraz ma kilka dodatków. Przede wszystkim dodano specjalizacje dla kilku rodzajów, więc dla wielu popularnych typów jest to znacznie szybsze niż przy użyciu ciągu znaków. Po drugie, teraz sprawdza wynik, więc (na przykład), jeśli przekształcisz ciąg intznaków w ciąg znaków, może zgłosić wyjątek, jeśli ciąg znaków zawiera coś, czego nie można przekonwertować na ciąg znaków int(np. 1234Powiedzie się, ale123abc zwróci) .

Począwszy od C ++ 11, istnieje std::to_stringfunkcja przeciążona dla typów całkowitych, więc możesz użyć kodu takiego jak:

int a = 20;
std::string s = std::to_string(a);
// or: auto s = std::to_string(a);

Standard określa je jako równoważne temu konwersję z sprintf(stosując specyfikator konwersji, który odpowiada podanemu typ obiektu, na przykład %dza int), w buforze o odpowiedniej wielkości, a następnie stworzenie std::stringzawartości tego buforu.

Jeśli masz zainstalowany Boost (co powinieneś):

#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);

Byłoby łatwiej za pomocą stringstreams:

#include <sstream>

int x = 42;          // The integer
string str;          // The string
ostringstream temp;  // 'temp' as in temporary
temp << x;
str = temp.str();    // str is 'temp' as string

Lub wykonaj funkcję:

#include <sstream>

string IntToString(int a)
{
    ostringstream temp;
    temp << a;
    return temp.str();
}

Nie wiem o tym w czystym C ++. Ale mała modyfikacja tego, o czym wspomniałeś

string s = string(itoa(a));

powinien działać i jest dość krótki.

Możesz użyć std::to_stringdostępne w C ++ 11, zgodnie z sugestią Matthieu M .:

std::to_string(42);

Lub, jeśli wydajność jest krytyczna (na przykład, jeśli robisz dużo konwersji), można skorzystać fmt::format_intz {} fmt biblioteki przekonwertować liczbę całkowitą do std::string:

fmt::format_int(42).str();

Lub ciąg C:

fmt::format_int f(42);
f.c_str();

Ten ostatni nie dokonuje żadnych dynamicznych alokacji pamięci i jest ponad 10 razy szybszy niż std::to_stringw testach Boost Karma. Zobacz Szybka konwersja liczb całkowitych na ciąg w C ++ uzyskać więcej informacji, .

Pamiętaj, że oba są bezpieczne dla wątków.

W przeciwieństwie std::to_string,fmt::format_int nie wymaga C ++ 11 i działa z dowolnym kompilatorem C ++.

Oświadczenie: Jestem autorem biblioteki {fmt}.

sprintf()jest całkiem dobry do konwersji formatu. Następnie możesz przypisać wynikowy ciąg C do ciągu C ++, tak jak w 1.

Najpierw obejmują:

#include <string>
#include <sstream>

Następnie dodaj metodę:

template <typename T>
string NumberToString(T pNumber)
{
 ostringstream oOStrStream;
 oOStrStream << pNumber;
 return oOStrStream.str();
}

Użyj następującej metody:

NumberToString(69);

lub

int x = 69;
string vStr = NumberToString(x) + " Hello word!."

Używanie strumienia ciągów do konwersji liczb jest niebezpieczne!

Zobacz http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/, gdzie informuje, że operator<<wstawia sformatowane dane wyjściowe.

W zależności od bieżących ustawień regionalnych liczba całkowita większa niż 3 cyfry może zostać przekształcona na ciąg 4 cyfr, dodając dodatkowy separator tysięcy.

Np. int = 1000Może być konwertowany na ciąg 1.001. Może to spowodować, że operacje porównania w ogóle nie będą działać.

Tak więc zdecydowanie polecam korzystanie z tego std::to_stringsposobu. Jest łatwiej i robi to, czego oczekujesz.

Zaktualizowano (patrz komentarze poniżej) :

C ++ 17 zapewnia std::to_charswyższą wydajność niezależną od ustawień lokalnych

W przypadku C ++ 98 istnieje kilka opcji:

boost/lexical_cast

Zwiększenie nie jest częścią biblioteki C ++, ale zawiera wiele przydatnych rozszerzeń bibliotek.

lexical_castSzablon funkcja oferuje wygodny i spójną formę do wspierania wspólnych konwersji do iz dowolnych typów, gdy są one reprezentowane jako tekst.
- Dokumentacja doładowania

#include "boost/lexical_cast.hpp"
#include <string>

int main() {
    int x = 5;
    std::string x_str = boost::lexical_cast<std::string>(x);
    return 0;
}

Jeśli chodzi o środowisko wykonawcze, lexical_castoperacja zajmuje około 80 mikrosekund (na moim komputerze) przy pierwszej konwersji, a następnie znacznie przyspiesza, jeśli zostanie wykonana nadmiarowo.

itoa

Ta funkcja nie jest zdefiniowana w ANSI-C i nie jest częścią C ++, ale jest obsługiwana przez niektóre kompilatory.
- cplusplus.com

Oznacza to, że gcc/ g++nie można skompilować kodu przy użyciu itoa.

#include <stdlib.h>

int main() {
    int x = 5;
    char * x_str = new char[2];
    x_str = itoa(x, x_str, 10); // base 10
    return 0;
}

Brak środowiska wykonawczego do zgłoszenia. Nie mam zainstalowanego programu Visual Studio, który podobno jest w stanie skompilować itoa.

sprintf

sprintf jest standardową funkcją biblioteki C, która działa na łańcuchach C i jest doskonale poprawną alternatywą.

Tworzy ciąg z tym samym tekstem, który zostałby wydrukowany, gdyby w printf użyto formatu, ale zamiast go wydrukować, zawartość jest przechowywana jako ciąg C w buforze wskazanym przez str.
- cplusplus.com

#include <stdio.h>

int main() {
    int x = 5;
    char * x_str = new char[2];
    int chars_written = sprintf(x_str, "%d", x);
    return 0;
}

stdio.hNagłówek może nie być konieczne. Jeśli chodzi o środowisko wykonawcze, sprintfoperacja zajmuje około 40 mikrosekund (na moim komputerze) przy pierwszej konwersji, a następnie znacznie przyspiesza, jeśli zostanie wykonana nadmiarowo.

stringstream

Jest to główny sposób konwersji liczb całkowitych na ciągi znaków w bibliotece C ++ i odwrotnie. Istnieją podobne funkcje siostrzane, stringstreamktóre dodatkowo ograniczają zamierzone użycie strumienia, takie jak ostringstream. Użycie w ostringstreamszczególności mówi czytelnikowi twojego kodu, że <<zasadniczo zamierzasz korzystać z operatora. Ta funkcja jest wszystkim, co jest szczególnie potrzebne do konwersji liczby całkowitej na ciąg. Zobacz to pytanie, aby uzyskać bardziej szczegółową dyskusję.

#include <sstream>
#include <string>

int main() {
    int x = 5;
    std::ostringstream stream;
    stream << x;
    std::string x_str = stream.str();
    return 0;
}

Jeśli chodzi o środowisko wykonawcze, ostringstreamoperacja zajmuje około 71 mikrosekund (na moim komputerze), a następnie znacznie przyspiesza, jeśli jest wykonywana nadmiarowo, ale nie o tyle, co poprzednie funkcje .

Oczywiście istnieją inne opcje i możesz nawet zawinąć jedną z nich we własną funkcję, ale oferuje to analityczne spojrzenie na niektóre z popularnych.

C ++ 17 zapewnia std :: to_chars jako wydajniejszą alternatywę niezależną od ustawień regionalnych.

Dość łatwo jest dodać cukier syntaktyczny, który pozwala komponować struny w locie w sposób podobny do strumienia

#include <string>
#include <sstream>

struct strmake {
    std::stringstream s;
    template <typename T> strmake& operator << (const T& x) {
        s << x; return *this;
    }   
    operator std::string() {return s.str();}
};

Teraz możesz dołączyć, co chcesz (pod warunkiem, że operator << (std::ostream& ..)jest dla niego zdefiniowany) strmake()i używać go zamiast std::string.

Przykład:

#include <iostream>

int main() {
    std::string x =
      strmake() << "Current time is " << 5+5 << ":" << 5*5 << " GST";
    std::cout << x << std::endl;
}

EDYTOWANE. Jeśli potrzebujesz szybkiej konwersji liczby całkowitej ze stałą liczbą cyfr na znak * uzupełniony lewy „0” , jest to przykład architektury little-endian (wszystkie x86, x86_64 i inne):

Jeśli konwertujesz dwucyfrowy numer:

int32_t s = 0x3030 | (n/10) | (n%10) << 8;

Jeśli konwertujesz trzycyfrową liczbę:

int32_t s = 0x303030 | (n/100) | (n/10%10) << 8 | (n%10) << 16;

Jeśli konwertujesz czterocyfrową liczbę:

int64_t s = 0x30303030 | (n/1000) | (n/100%10)<<8 | (n/10%10)<<16 | (n%10)<<24;

I tak dalej do siedmiocyfrowych liczb. W tym przykładzie npodana jest liczba całkowita. Po konwersji można wyświetlić reprezentację ciągu jako (char*)&s:

std::cout << (char*)&s << std::endl;

UWAGA: Jeśli potrzebujesz go w kolejności bajtów big-endian, chociaż go nie testowałem, ale oto przykład: dla liczby trzycyfrowej jest to int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;dla liczb czterocyfrowych (łuk 64-bitowy): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;Myślę, że powinno działać.

Posługiwać się:

#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}

Używam:

int myint = 0;
long double myLD = 0.0;

string myint_str = static_cast<ostringstream*>(&(ostringstream() << myint))->str();
string myLD_str = static_cast<ostringstream*>(&(ostringstream() << myLD))->str();

Działa na moich kompilatorach g ++ dla Windows i Linux.

Oto kolejny prosty sposób

char str[100];
sprintf(str, "%d", 101);
string s = str;

sprintf jest dobrze znany do wstawiania dowolnych danych do ciągu o wymaganym formacie.

Możesz przekonwertować char *tablicę na ciąg, jak pokazano w trzecim wierszu.

To zadziałało dla mnie -

Mój kod:

#include <iostream>
using namespace std;

int main()
{
    int n = 32;
    string s = to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}

C ++ 11 wprowadzony std::to_string()dla typów numerycznych:

int n = 123; // Input, signed/unsigned short/int/long/long long/float/double
std::string str = std::to_string(n); // Output, std::string

Posługiwać się:

#include<iostream>
#include<string>

std::string intToString(int num);

int main()
{
    int integer = 4782151;

    std::string integerAsStr = intToString(integer);

    std::cout << "integer = " << integer << std::endl;
    std::cout << "integerAsStr = " << integerAsStr << std::endl;

    return 0;
}

std::string intToString(int num)
{
    std::string numAsStr;

    while (num)
    {
        char toInsert = (num % 10) + 48;
        numAsStr.insert(0, 1, toInsert);

        num /= 10;
    }
    return numAsStr;
}

string number_to_string(int x) {

    if (!x)
        return "0";

    string s, s2;
    while(x) {
        s.push_back(x%10 + '0');
        x /= 10;
    }
    reverse(s.begin(), s.end());
    return s;
}

Jeśli używasz MFC , możesz użyć CString:

int a = 10;
CString strA;
strA.Format("%d", a);

char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);

namespace std
{
    inline string to_string(int _Val)
    {   // Convert long long to string
        char _Buf[2 * _MAX_INT_DIG];
        snprintf(_Buf, "%d", _Val);
        return (string(_Buf));
    }
}

Możesz teraz użyć to_string(5).

Myślę, że korzystanie stringstreamjest dość łatwe:

 string toString(int n)
 {
     stringstream ss(n);
     ss << n;
     return ss.str();
 }

 int main()
 {
    int n;
    cin >> n;
    cout << toString(n) << endl;
    return 0;
 }

Algorytm typu licznika służy do konwersji na ciąg znaków. Technikę tę dostałem od programowania komputerów Commodore 64 . Jest także dobry do programowania gier.

• Bierzesz liczbę całkowitą i bierzesz każdą cyfrę ważoną potęgami 10. Załóżmy, że liczba całkowita wynosi 950.

  • Jeśli liczba całkowita jest równa lub większa niż 100 000, to odejmij 100 000 i zwiększ licznik w ciągu [000000];
    rób to dalej, aż nie będzie więcej liczb na pozycji 100 000. Upuść kolejną potęgę dziesięciu.

  • Jeśli liczba całkowita jest równa lub większa niż 10 000, to odejmij 10 000 i zwiększ licznik w ciągu w pozycji [„000000”] + 1 pozycja;
    rób to dalej, aż nie będzie więcej liczb na pozycji 10.000.

• Upuść kolejną potęgę dziesięciu

• Powtórz wzór

Wiem, że 950 jest zbyt mały, aby go użyć jako przykładu, ale mam nadzieję, że wpadłeś na ten pomysł.