Cách dễ nhất để chuyển đổi int thành chuỗi trong C ++

Cách dễ nhất để chuyển đổi từ inttương đương stringtrong C ++ là gì. Tôi nhận thức được hai phương pháp. Có cách nào dễ dàng hơn không?

(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 giới thiệu std::stoi (và các biến thể cho từng loại số) và std::to_string, các bản sao của C atoivà được itoathể hiện dưới dạng std::string.

#include <string> 

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

do đó là cách ngắn nhất tôi có thể nghĩ ra. Bạn thậm chí có thể bỏ qua việc đặt tên loại, sử dụng autotừ khóa:

auto s = std::to_string(42);

Lưu ý: xem [string.conversions] ( 21.5 trong n3242 )

Chọn một cuộc thảo luận với @ v.oddou một vài năm sau đó, C ++ 17 cuối cùng đã đưa ra một cách để thực hiện giải pháp loại bất khả tri dựa trên vĩ mô ban đầu (được bảo tồn bên dưới) mà không phải trải qua sự xấu xí vĩ mô.

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

Sử dụng:

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

Câu trả lời gốc:

Vì "chuyển đổi ... thành chuỗi" là một vấn đề lặp đi lặp lại, tôi luôn xác định macro SSTR () trong tiêu đề trung tâm của các nguồn C ++ của mình:

#include <sstream>

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

Cách sử dụng dễ dàng nhất có thể:

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

Ở trên là tương thích C ++ 98 (nếu bạn không thể sử dụng C ++ 11 std::to_string) và không cần bất kỳ bên thứ ba nào bao gồm (nếu bạn không thể sử dụng Boost lexical_cast<>); cả hai giải pháp khác có hiệu suất tốt hơn mặc dù.

Tôi thường sử dụng phương pháp sau:

#include <sstream>

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

Nó được mô tả chi tiết ở đây .

Có lẽ cách dễ dàng phổ biến nhất bao bọc về cơ bản sự lựa chọn thứ hai của bạn vào một mẫu có tên lexical_cast, chẳng hạn như mẫu trong Boost , vì vậy mã của bạn trông như thế này:

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

Một điều thú vị của điều này là nó cũng hỗ trợ các diễn viên khác (ví dụ, theo hướng ngược lại cũng hoạt động tốt).

Cũng lưu ý rằng mặc dù Boost lexical_cast bắt đầu như chỉ ghi vào một chuỗi, sau đó trích xuất ra khỏi luồng, nhưng bây giờ nó có một vài bổ sung. Trước hết, các chuyên ngành cho khá nhiều loại đã được thêm vào, vì vậy đối với nhiều loại phổ biến, nó nhanh hơn đáng kể so với sử dụng chuỗi. Thứ hai, bây giờ nó sẽ kiểm tra kết quả, vì vậy (ví dụ) nếu bạn chuyển đổi từ một chuỗi thành một chuỗi int, nó có thể ném ngoại lệ nếu chuỗi chứa thứ gì đó không thể chuyển đổi thành int(ví dụ: 1234sẽ thành công, nhưng 123abcsẽ ném) .

Kể từ C ++ 11, có một std::to_stringhàm bị quá tải cho các kiểu số nguyên, vì vậy bạn có thể sử dụng mã như:

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

Các định nghĩa tiêu chuẩn này là tương đương với thực hiện chuyển đổi với sprintf(sử dụng sự xác định chuyển đổi phù hợp với loại đã cung cấp của đối tượng, chẳng hạn như %dcho int), vào một bộ đệm đủ kích thước, sau đó tạo ra một std::stringtrong những nội dung của bộ đệm đó.

Nếu bạn đã cài đặt Boost (mà bạn nên):

#include <boost/lexical_cast.hpp>

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

Nó sẽ dễ dàng hơn bằng cách sử dụng chuỗi dòng:

#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

Hoặc thực hiện một chức năng:

#include <sstream>

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

Không phải tôi biết, trong C ++ thuần túy. Nhưng một chút sửa đổi những gì bạn đã đề cập

string s = string(itoa(a));

nên hoạt động, và nó khá ngắn.

Bạn có thể sử dụng std::to_stringcó sẵn trong C ++ 11 theo đề xuất của Matthieu M . :

std::to_string(42);

Hoặc, nếu hiệu suất là quan trọng (ví dụ: nếu bạn thực hiện nhiều chuyển đổi), bạn có thể sử dụng fmt::format_inttừ thư viện {fmt} để chuyển đổi một số nguyên sang std::string:

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

Hoặc một chuỗi C:

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

Loại thứ hai không thực hiện bất kỳ phân bổ bộ nhớ động nào và nhanh hơn 10 lần so với std::to_stringđiểm chuẩn Boost Karma. Xem Chuyển đổi số nguyên nhanh sang chuỗi trong C ++ để biết thêm chi tiết.

Lưu ý rằng cả hai đều an toàn chủ đề.

Không giống như std::to_string, fmt::format_intkhông yêu cầu C ++ 11 và hoạt động với bất kỳ trình biên dịch C ++ nào.

Tuyên bố miễn trừ trách nhiệm: Tôi là tác giả của thư viện {fmt}.

sprintf()là khá tốt để chuyển đổi định dạng. Sau đó, bạn có thể gán chuỗi C kết quả cho chuỗi C ++ như bạn đã làm trong 1.

Đầu tiên bao gồm:

#include <string>
#include <sstream>

Thứ hai thêm phương thức:

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

Sử dụng phương pháp như thế này:

NumberToString(69);

hoặc là

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

Sử dụng chuỗi để chuyển đổi số là nguy hiểm!

Xem http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ nơi thông báo rằng operator<<chèn đầu ra được định dạng.

Tùy thuộc vào ngôn ngữ hiện tại của bạn một số nguyên lớn hơn 3 chữ số, có thể chuyển đổi thành một chuỗi gồm 4 chữ số, thêm một dấu phân cách hàng nghìn.

Ví dụ, int = 1000có thể được chuyển đổi thành một chuỗi 1.001. Điều này có thể làm cho các hoạt động so sánh không hoạt động.

Vì vậy, tôi rất muốn giới thiệu cách sử dụng std::to_string. Nó dễ dàng hơn và làm những gì bạn mong đợi.

Cập nhật (xem bình luận bên dưới) :

C ++ 17 cung cấp std::to_charsnhư là một thay thế độc lập địa phương hiệu suất cao hơn

Đối với C ++ 98 , có một vài lựa chọn:

boost/lexical_cast

Boost không phải là một phần của thư viện C ++, nhưng chứa nhiều phần mở rộng thư viện hữu ích.

Mẫu lexical_casthàm cung cấp một hình thức thuận tiện và nhất quán để hỗ trợ các chuyển đổi phổ biến đến và từ các loại tùy ý khi chúng được thể hiện dưới dạng văn bản.
- Tài liệu của 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;
}

Đối với thời gian chạy, lexical_casthoạt động mất khoảng 80 micro giây (trên máy của tôi) trong lần chuyển đổi đầu tiên, và sau đó tăng tốc đáng kể sau đó nếu được thực hiện dự phòng.

itoa

Hàm này không được định nghĩa trong ANSI-C và không phải là một phần của C ++, nhưng được một số trình biên dịch hỗ trợ.
- cplusplus.com

Điều này có nghĩa là gcc/ g++không thể biên dịch mã bằng cách sử dụng 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;
}

Không có thời gian chạy để báo cáo. Tôi không có Visual Studio cài đặt, đó là báo cáo có thể biên dịch itoa.

sprintf

sprintf là một hàm thư viện chuẩn C hoạt động trên các chuỗi C và là một thay thế hoàn toàn hợp lệ.

Soạn một chuỗi có cùng văn bản sẽ được in nếu định dạng được sử dụng trên printf, nhưng thay vì được in, nội dung được lưu dưới dạng chuỗi C trong bộ đệm được chỉ bởi 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;
}

Các stdio.htiêu đề có thể không cần thiết. Đối với thời gian chạy, sprintfhoạt động mất khoảng 40 micro giây (trên máy của tôi) trong lần chuyển đổi đầu tiên, và sau đó tăng tốc đáng kể sau đó nếu được thực hiện dự phòng.

stringstream

Đây là cách chính của thư viện C ++ để chuyển đổi số nguyên thành chuỗi và ngược lại. Có các chức năng tương tự để stringstreamhạn chế hơn nữa mục đích sử dụng của luồng, chẳng hạn như ostringstream. Việc sử dụng ostringstreamcụ thể cho người đọc mã của bạn rằng bạn chỉ có ý định sử dụng <<toán tử. Hàm này là tất cả những gì đặc biệt cần thiết để chuyển đổi một số nguyên thành một chuỗi. Xem câu hỏi này để thảo luận chi tiết hơn.

#include <sstream>
#include <string>

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

Đối với thời gian chạy, ostringstreamhoạt động mất khoảng 71 micro giây (trên máy của tôi), và sau đó tăng tốc đáng kể sau đó nếu được thực hiện dự phòng, nhưng không nhiều như các chức năng trước đó .

Tất nhiên có những lựa chọn khác, và bạn thậm chí có thể bọc một trong số chúng vào chức năng của riêng bạn, nhưng điều này mang lại cái nhìn phân tích về một số trong những cái phổ biến.

C ++ 17 cung cấp std :: to_chars như một sự thay thế độc lập với miền địa phương hiệu suất cao hơn.

Thật dễ dàng để thêm một số đường cú pháp cho phép người ta soạn các chuỗi một cách nhanh chóng theo cách giống như luồng

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

Bây giờ bạn có thể nối bất cứ thứ gì bạn muốn (với điều kiện là một toán tử << (std::ostream& ..)được xác định cho nó) strmake()và sử dụng nó thay cho một std::string.

Thí dụ:

#include <iostream>

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

EDITED. Nếu bạn cần chuyển đổi nhanh một số nguyên có số chữ số cố định thành char * được đệm trái với '0' , đây là ví dụ cho các kiến ​​trúc cuối nhỏ (tất cả x86, x86_64 và các số khác):

Nếu bạn đang chuyển đổi một số có hai chữ số:

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

Nếu bạn đang chuyển đổi một số có ba chữ số:

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

Nếu bạn đang chuyển đổi một số có bốn chữ số:

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

Và cứ như vậy lên đến bảy chữ số. Trong ví dụ nnày là một số nguyên cho trước. Sau khi chuyển đổi, biểu diễn chuỗi có thể được truy cập dưới dạng (char*)&s:

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

LƯU Ý: Nếu bạn cần nó theo thứ tự byte cuối lớn, mặc dù tôi đã không kiểm tra nó, nhưng đây là một ví dụ: đối với số có ba chữ số, nó int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;dành cho số có bốn chữ số (vòm 64 bit): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;Tôi nghĩ rằng nó nên hoạt động.

Sử dụng:

#define convertToString(x) #x

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

Tôi sử dụng:

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

Nó hoạt động trên trình biên dịch Windows và Linux g ++ của tôi.

Đây là một cách dễ dàng để làm

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

sprintf là một công cụ nổi tiếng để chèn bất kỳ dữ liệu nào vào một chuỗi có định dạng bắt buộc.

Bạn có thể chuyển đổi một char *mảng thành một chuỗi như trong dòng thứ ba.

Điều này làm việc cho tôi -

Mã của tôi:

#include <iostream>
using namespace std;

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

C ++ 11 được giới thiệu std::to_string()cho các loại số:

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

Sử dụng:

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

Nếu bạn đang sử dụng MFC , bạn có thể sử dụng 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));
    }
}

Bây giờ bạn có thể sử dụng to_string(5).

Tôi nghĩ rằng việc sử dụng stringstreamlà khá dễ dàng:

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

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

Bạn sử dụng một loại thuật toán truy cập để chuyển đổi thành một chuỗi. Tôi đã có được kỹ thuật này từ lập trình máy tính Commodore 64 . Nó cũng tốt cho lập trình trò chơi.

• Bạn lấy số nguyên và lấy mỗi chữ số có trọng số bằng 10. Vì vậy, giả sử số nguyên là 950.

  • Nếu số nguyên bằng hoặc lớn hơn 100.000 thì trừ 100.000 và tăng bộ đếm trong chuỗi tại ["000000"];
    tiếp tục làm cho đến khi không còn số ở vị trí 100.000. Thả một sức mạnh khác của mười.

  • Nếu số nguyên bằng hoặc lớn hơn 10.000 thì trừ 10.000 và tăng bộ đếm trong chuỗi tại ["000000"] + 1 vị trí;
    tiếp tục làm cho đến khi không còn số ở vị trí 10.000.

• Giảm sức mạnh khác của mười

• Lặp lại mô hình

Tôi biết 950 quá nhỏ để sử dụng làm ví dụ, nhưng tôi hy vọng bạn có ý tưởng.