Najprostszy sposób konwersji int na string w C++

Rozpoczynając dyskusję z @V. oddou kilka lat później, C++17 W końcu dostarczył sposób na wykonanie oryginalnego rozwiązania agnostycznego typu opartego na makrach (zachowanego poniżej) Bez przechodzenia przez brzydotę makr.

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

Użycie:

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ź:

Od " konwersja ... to string " 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 może 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 rozwiązanie jest kompatybilne z C++98 (jeśli nie możesz użyć C++11 std::to_string) i nie wymaga żadnych zewnętrznych elementów (jeśli nie możesz użyć Boost lexical_cast<>); oba te inne rozwiązania mają jednak lepszą wydajność.

Zwykle stosuję następującą metodę:

#include <sstream>

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

Opisane szczegółowo tutaj .

Prawdopodobnie najpopularniejszy prosty sposób zawija zasadniczo twój drugi wybór w szablon o nazwie lexical_cast, taki jak ten w Boost , więc Twój kod wygląda tak:

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

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

Zauważ również, że chociaż boost lexical_cast zaczynał jako pisanie do strumienia strumieniowego, a następnie wydobywanie ze strumienia, teraz ma kilka dodatków. Pierwszy z wszystkie specjalizacje dla kilku typów zostały dodane, więc dla wielu popularnych typów jest to znacznie szybsze niż użycie stringstream. Po drugie, sprawdza teraz wynik, więc (na przykład) jeśli przekonwertujesz łańcuch na int, może rzucić wyjątek, jeśli łańcuch zawiera coś, czego nie można przekonwertować na int (np. 1234 powiedzie się, ale 123abc rzuci).

Od C++11 istnieje funkcja std::to_string przeciążona dla typów całkowitych, dzięki czemu można używać kodu like:

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

Standard definiuje je jako równoważne z wykonaniem konwersji za pomocą sprintf (używając specyfikatora konwersji, który pasuje do dostarczonego typu obiektu, takiego jak %d dla int), do bufora o wystarczającej wielkości, a następnie tworząc std::string zawartości tego bufora.

Jeśli masz zainstalowany Boost (który powinieneś):

#include <boost/lexical_cast.hpp>

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

Nie byłoby łatwiej używać 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 zrób funkcję:

#include <sstream>

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

Nic mi o tym nie wiadomo, w czystym C++. Ale mała modyfikacja tego, o czym wspomniałeś

string s = string(itoa(a));

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

Pierwszy zawiera:

#include <string>
#include <sstream>

Drugi Dodaj metodę:

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

Użyj metody w ten sposób:

NumberToString(69);

Lub

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

Możesz użyć std::to_string dostępnego w C++11 jako zasugerowanego przez Matthieu M.:

std::to_string(42);

Lub, jeśli wydajność jest krytyczna (na przykład, jeśli wykonujesz wiele konwersji), możesz użyć fmt::FormatInt z biblioteki C++ Format, Aby przekonwertować liczbę całkowitą na std::string:

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

Lub ciąg C:

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

Ten ostatni nie robi żadnych dynamicznych alokacji pamięci i jest ponad 10 razy szybszy niż std::to_string w benchmarkach Boost Karma. Zobacz też Szybka konwersja liczby całkowitej na ciąg znaków w C++ Po Więcej Szczegółów.

W przeciwieństwie std::to_string, fmt::FormatInt nie wymaga C++11 i współpracuje z dowolnym kompilatorem C++.

Zastrzeżenie: jestem autorem Biblioteki formatu C++.

Używanie stringstream do konwersji liczb jest niebezpieczne!

Zobacz http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/{[10] } gdzie mówi, że operator<< wstawia sformatowane wyjście.

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

Np. {[1] } może być konwertowany na łańcuch 1.001. Może to spowodować, że operacje porównawcze nie będą działać w wszystkie.

Więc zdecydowanie polecam użycie std::to_string sposób. Jest łatwiejsze i robi to, czego oczekujesz.

Dla C++98 istnieje kilka opcji:

boost/lexical_cast

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

Szablon funkcji lexical_cast oferuje wygodną i spójną formę do obsługi typowych konwersji do i z dowolnych typów, gdy są one reprezentowane jako tekst.
-- dokumentacja Boosta

#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 runtime, operacja lexical_cast trwa około 80 mikrosekund (na mojej maszynie) przy pierwszej konwersji, a następnie znacznie przyspiesza po wykonaniu redundantnie.

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 używając 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 runtime do zgłoszenia. Nie mam zainstalowanego Visual Studio, które jest podobno w stanie skompilować itoa.

sprintf

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

Tworzy ciąg znaków z tym samym tekstem, który byłby wydrukowany, gdyby format był używany na printf, ale zamiast drukować, 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;
}

Nagłówek stdio.h może nie być konieczny. Jeśli chodzi o runtime, operacja sprintf zajmuje około 40 mikrosekund (na moim komputerze) przy pierwszej konwersji, a następnie znacznie przyspiesza, jeśli zostanie wykonana redundantnie.

stringstream

Jest to główny sposób konwersji liczb całkowitych na ciągi znaków i odwrotnie. Istnieją podobne siostrzane funkcje do stringstream, które dodatkowo ograniczają zamierzone użycie strumienia, takie jak ostringstream. Użycie ostringstream wyraźnie mówi czytelnikowi Twojego kodu, że zamierzasz używać wyłącznie operatora <<. To funkcja jest wszystkim, co jest szczególnie potrzebne do konwersji liczby całkowitej na ciąg znaków. Zobacz to pytanie dla bardziej rozbudowanej dyskusji.

#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 runtime, operacja ostringstream zajmuje około 71 mikrosekund (na moim komputerze), a następnie znacznie przyspiesza, jeśli jest wykonywana redundantnie, ale nie tak bardzo, jak poprzednie funkcje.

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

Użycie:

#define convertToString(x) #x

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

Dość łatwo jest dodać trochę cukru składniowego, 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ć cokolwiek chcesz (pod warunkiem, że operator << (std::ostream& ..) jest zdefiniowany dla niego) do strmake() i użyć 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;
}

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)

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 windows i linux g++.

Używając CString:

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

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

#include "stdafx.h"
#include<iostream>
#include<string>
#include<string.h>


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

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

Jeśli potrzebujesz szybkiej konwersji liczby całkowitej ze stałą liczbą cyfr na znak * z lewej strony z "0", jest to wygodny przykład:

int n = 27;
char s[8];

Jeśli konwertujesz dwucyfrową liczbę:

*(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 aż do siedmiocyfrowych liczb :)

Oto kolejny łatwy sposób na zrobienie

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

Sprintf jest dobrze znany, aby wstawić dowolne dane do ciągu wymaganego formatu .

Możesz przekonwertować tablicę znaków * na łańcuch znaków, jak pokazano w trzeciej linii.

int n = 123;
std::string str = std::to_string(n);

Myślę, że korzystanie z stringstream jest 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;
 }

Używasz algorytmu typu counter do konwersji na ciąg znaków. Zdobyłem tę technikę od programowania komputerów Commodore 64. Jest również dobry do programowania gier.

• Bierzesz liczbę całkowitą i bierzesz każdą cyfrę ważoną przez potęgi 10. Więc załóżmy, że liczba całkowita wynosi 950.

  • Jeśli liczba całkowita jest równa lub większa niż 100 000, to odjmij 100 000 i zwiększ licznik w łańcuchu o ["000000"];
    rób tak dalej, aż nie będzie więcej numerów w pozycji 100 tys. Drop another power of ten

  • Jeśli liczba całkowita jest równa lub większa niż 10 000, to odjmij 10 000 i zwiększ licznik w łańcuchu na ["000000"] + 1 pozycja;
    rób tak dalej, aż nie będzie więcej numerów na pozycji 10,000.

• Drop another power of ten

• powtórz wzór

Wiem, że 950 jest za mały, aby użyć jako przykład, ale mam nadzieję, że masz pomysł.