Cara termudah untuk mengkonversi int ke string di C ++

Apa cara termudah untuk mengkonversi dari intmenjadi setara stringdi C ++. Saya mengetahui dua metode. Apakah ada cara yang lebih mudah?

(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 memperkenalkan std::stoi(dan varian untuk setiap jenis numerik) dan std::to_string, rekan-rekan dari C atoidan itoatetapi dinyatakan dalam istilah std::string.

#include <string> 

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

Oleh karena itu cara terpendek yang dapat saya pikirkan. Anda bahkan dapat menghilangkan penamaan tipe, menggunakan autokata kunci:

auto s = std::to_string(42);

Catatan: lihat [string.conversions] ( 21.5 di n3242 )

Mengambil diskusi dengan @ v.oddou beberapa tahun kemudian, C ++ 17 akhirnya memberikan cara untuk melakukan solusi agnostik tipe makro yang awalnya (disimpan di bawah) tanpa melalui keburukan makro.

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

Pemakaian:

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

Jawaban asli:

Karena "konversi ... ke string" adalah masalah berulang, saya selalu mendefinisikan makro SSTR () di header pusat sumber C ++ saya:

#include <sstream>

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

Penggunaannya semudah:

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

Di atas adalah kompatibel C ++ 98 (jika Anda tidak dapat menggunakan C ++ 11 std::to_string), dan tidak memerlukan pihak ketiga termasuk (jika Anda tidak dapat menggunakan Boost lexical_cast<>); kedua solusi lain ini memiliki kinerja yang lebih baik.

Saya biasanya menggunakan metode berikut:

#include <sstream>

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

Dijelaskan secara rinci di sini .

Mungkin cara paling mudah yang paling umum adalah membungkus pilihan kedua Anda ke dalam templat bernama lexical_cast, seperti yang ada di Boost , sehingga kode Anda terlihat seperti ini:

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

Satu kebaikan dari ini adalah bahwa ia mendukung gips lain juga (misalnya, dalam arah yang berlawanan berfungsi juga).

Perhatikan juga bahwa meskipun Lexical_cast Boost dimulai sebagai hanya menulis ke stringstream, kemudian mengekstrak kembali dari aliran, sekarang memiliki beberapa tambahan. Pertama-tama, spesialisasi untuk beberapa jenis telah ditambahkan, jadi untuk banyak jenis umum, ini jauh lebih cepat daripada menggunakan stringstream. Kedua, sekarang memeriksa hasilnya, jadi (misalnya) jika Anda mengonversi dari string ke int, ia dapat melempar pengecualian jika string berisi sesuatu yang tidak dapat dikonversi ke int(misalnya, 1234akan berhasil, tetapi 123abcakan melempar) .

Pada C ++ 11, ada std::to_stringfungsi kelebihan untuk tipe integer, sehingga Anda dapat menggunakan kode seperti:

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

Standar mendefinisikan ini sebagai setara dengan melakukan konversi dengan sprintf(menggunakan specifier konversi yang cocok dengan jenis objek yang disediakan, seperti %duntuk int), ke dalam buffer dengan ukuran yang cukup, kemudian membuat std::stringkonten buffer tersebut.

Jika Anda telah memasang Boost (yang seharusnya):

#include <boost/lexical_cast.hpp>

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

Akan lebih mudah menggunakan 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

Atau buat fungsi:

#include <sstream>

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

Bukan yang saya tahu, di C + + murni. Namun sedikit modifikasi dari apa yang Anda sebutkan

string s = string(itoa(a));

harus bekerja, dan itu cukup singkat.

Anda dapat menggunakan yang std::to_stringtersedia di C ++ 11 seperti yang disarankan oleh Matthieu M .:

std::to_string(42);

Atau, jika kinerja sangat penting (misalnya, jika Anda melakukan banyak konversi), Anda dapat menggunakan fmt::format_intdari perpustakaan {fmt} untuk mengonversi integer menjadi std::string:

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

Atau string C:

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

Yang terakhir ini tidak melakukan alokasi memori dinamis dan lebih dari 10 kali lebih cepat daripada std::to_stringpada benchmark Boost Karma. Lihat Konversi integer cepat ke string dalam C ++ untuk detail lebih lanjut.

Perhatikan bahwa keduanya aman.

Tidak seperti std::to_string, fmt::format_inttidak memerlukan C ++ 11 dan bekerja dengan kompiler C ++.

Penafian: Saya penulis perpustakaan {fmt}.

sprintf()cukup bagus untuk konversi format. Anda kemudian dapat menetapkan string C yang dihasilkan ke string C ++ seperti yang Anda lakukan pada 1.

Pertama termasuk:

#include <string>
#include <sstream>

Kedua, tambahkan metode:

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

Gunakan metode seperti ini:

NumberToString(69);

atau

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

Menggunakan stringstream untuk konversi angka berbahaya!

Lihat http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ di mana ia memberi tahu bahwa operator<<sisipan keluaran terformat.

Bergantung pada lokasi Anda saat ini, bilangan bulat yang lebih besar dari 3 digit, dapat dikonversi menjadi string 4 digit, menambahkan pemisah ribuan tambahan.

Misal, int = 1000bisa jadi convertet menjadi string 1.001. Ini bisa membuat operasi perbandingan tidak berfungsi sama sekali.

Jadi saya sangat merekomendasikan menggunakan std::to_stringcara. Lebih mudah dan melakukan apa yang Anda harapkan.

Diperbarui (lihat komentar di bawah) :

C ++ 17 menyediakan std::to_charsalternatif independen lokal berkinerja tinggi

Untuk C ++ 98 , ada beberapa opsi:

boost/lexical_cast

Boost bukan bagian dari pustaka C ++, tetapi mengandung banyak ekstensi pustaka yang bermanfaat.

The lexical_castfungsi template menawarkan bentuk yang nyaman dan konsisten untuk mendukung konversi umum ke dan dari jenis sewenang-wenang ketika mereka direpresentasikan sebagai teks.
- Dokumentasi Boost

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

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

Adapun runtime, lexical_castoperasi membutuhkan sekitar 80 mikrodetik (pada mesin saya) pada konversi pertama, dan kemudian mempercepat setelah itu jika dilakukan secara berlebihan.

itoa

Fungsi ini tidak didefinisikan dalam ANSI-C dan bukan bagian dari C ++, tetapi didukung oleh beberapa kompiler.
- cplusplus.com

Ini berarti bahwa gcc/ g++tidak dapat mengkompilasi kode menggunakan 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;
}

Tidak ada runtime untuk dilaporkan. Saya tidak menginstal Visual Studio, yang dilaporkan dapat dikompilasi itoa.

sprintf

sprintf adalah fungsi pustaka standar C yang bekerja pada string C, dan merupakan alternatif yang benar-benar valid.

Membuat string dengan teks yang sama yang akan dicetak jika format digunakan pada printf, tetapi alih-alih dicetak, konten disimpan sebagai string C dalam buffer yang ditunjukkan oleh 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;
}

The stdio.hsundulan mungkin tidak diperlukan. Sedangkan untuk runtime, sprintfoperasi membutuhkan sekitar 40 mikrodetik (pada mesin saya) pada konversi pertama, dan kemudian mempercepat setelah itu jika dilakukan secara berlebihan.

stringstream

Ini adalah cara utama pustaka C ++ untuk mengonversi bilangan bulat menjadi string, dan sebaliknya. Ada fungsi saudara serupa dengan stringstreamyang selanjutnya membatasi penggunaan yang dimaksudkan aliran, seperti ostringstream. Menggunakan ostringstreamsecara khusus memberi tahu pembaca kode Anda bahwa Anda hanya bermaksud menggunakan <<operator, pada dasarnya. Fungsi ini adalah yang paling penting untuk mengonversi bilangan bulat menjadi string. Lihat pertanyaan ini untuk diskusi lebih lanjut.

#include <sstream>
#include <string>

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

Adapun runtime, ostringstreamoperasi membutuhkan sekitar 71 mikrodetik (pada mesin saya), dan kemudian mempercepat setelah itu jika dilakukan secara berlebihan, tetapi tidak sebanyak fungsi sebelumnya .

Tentu saja ada opsi lain, dan Anda bahkan dapat membungkus salah satu dari ini ke dalam fungsi Anda sendiri, tetapi ini menawarkan tampilan analitis pada beberapa yang populer.

C ++ 17 menyediakan std :: to_chars sebagai alternatif independen-lokal berkinerja tinggi.

Agak mudah untuk menambahkan beberapa gula sintaksis yang memungkinkan seseorang untuk menyusun string dengan cepat dengan cara seperti aliran

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

Sekarang Anda dapat menambahkan apa pun yang Anda inginkan (asalkan ada operator << (std::ostream& ..)yang ditentukan untuknya) strmake()dan menggunakannya sebagai pengganti std::string.

Contoh:

#include <iostream>

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

Diedit. Jika Anda membutuhkan cepat konversi integer dengan jumlah tetap digit ke char * kiri-empuk dengan '0' , ini adalah contoh untuk arsitektur little-endian (semua x86, x86_64 dan lain-lain):

Jika Anda mengonversi nomor dua digit:

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

Jika Anda mengonversi angka tiga digit:

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

Jika Anda mengonversi angka empat digit:

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

Demikian seterusnya hingga tujuh digit angka. Dalam contoh ini nadalah bilangan bulat yang diberikan. Setelah konversi itu representasi string dapat diakses sebagai (char*)&s:

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

CATATAN: Jika Anda membutuhkannya pada pesanan byte big-endian, meskipun saya tidak mengujinya, tetapi di sini adalah sebuah contoh: untuk nomor tiga digit itu int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;untuk nomor empat digit (lengkungan 64 bit): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;Saya pikir itu harus bekerja.

Menggunakan:

#define convertToString(x) #x

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

Saya menggunakan:

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

Ia bekerja pada kompiler Windows dan Linux g ++ saya.

Inilah cara mudah lainnya untuk dilakukan

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

sprintf adalah yang terkenal untuk memasukkan data apa pun ke dalam string format yang diperlukan.

Anda dapat mengubah char *array menjadi string seperti yang ditunjukkan pada baris ketiga.

Ini bekerja untuk saya -

Kode saya:

#include <iostream>
using namespace std;

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

C ++ 11 diperkenalkan std::to_string()untuk tipe numerik:

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

Menggunakan:

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

Jika Anda menggunakan MFC , Anda dapat menggunakan 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));
    }
}

Anda sekarang dapat menggunakan to_string(5).

Saya pikir menggunakan stringstreamcukup mudah:

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

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

Anda menggunakan tipe konter algoritma untuk mengkonversi ke string. Saya mendapatkan teknik ini dari pemrograman Commodore 64 komputer. Ini juga bagus untuk pemrograman game.

• Anda mengambil bilangan bulat dan mengambil setiap digit yang diberi bobot oleh kekuatan 10. Jadi anggap bilangan bulat adalah 950.

  • Jika bilangan bulat sama dengan atau lebih besar dari 100.000 maka kurangi 100.000 dan tambah penghitung dalam string di ["000000"];
    terus melakukannya sampai tidak ada lagi angka di posisi 100.000. Jatuhkan kekuatan sepuluh lainnya.

  • Jika bilangan bulat sama dengan atau lebih besar dari 10.000 maka kurangi 10.000 dan tambah penghitung dalam string pada ["000000"] +1 posisi;
    terus lakukan sampai tidak ada lagi angka di posisi 10.000.

• Jatuhkan kekuatan sepuluh lainnya

• Ulangi polanya

Saya tahu 950 terlalu kecil untuk digunakan sebagai contoh, tetapi saya harap Anda mendapatkan idenya.