C ++ ile int'i dizeye dönüştürmenin en kolay yolu

C ++ ' intda eşdeğerine dönüştürmenin en kolay yolu nedir string. İki yöntemin farkındayım. Daha kolay bir yolu var mı?

(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, std::stoi(ve her sayısal tip için varyantları) ve std::to_stringC'nin karşılıklarını sunar atoive itoaterimiyle ifade edilir std::string.

#include <string> 

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

bu yüzden düşünebildiğim en kısa yol. autoAnahtar kelimeyi kullanarak türün adını bile atlayabilirsiniz :

auto s = std::to_string(42);

Not: bakınız [string.conversions] ( 21.5 olarak n3242 )

Birkaç yıl sonra @ v.oddou ile bir tartışma toplarken, C ++ 17 nihayet (aşağıda korunmuş) orijinal olarak makro bazlı tip-agnostik bir çözüm yapmak için bir yol teslim etti olmadan makro uglyness geçiyor.

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

Kullanımı:

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

Orijinal cevap:

"... dize dönüştürme" yinelenen bir sorun olduğundan, her zaman S + () makro C ++ kaynaklarının merkezi üstbilgisinde tanımlamak :

#include <sstream>

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

Kullanımı olabildiğince kolaydır:

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

Yukarıdaki C ++ 98 uyumludur (C ++ 11 kullanamıyorsanız std::to_string) ve herhangi bir üçüncü taraf içermesi gerekmez (Boost kullanamıyorsanız lexical_cast<>); her iki çözüm de daha iyi bir performans sergiliyor.

Genellikle aşağıdaki yöntemi kullanırım:

#include <sstream>

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

Bu ayrıntılar açıklanmıştır burada .

Muhtemelen en yaygın kolay yolu adında bir şablona esasen ikinci seçim sarar lexical_castböyle de biri olarak, Boost böyle kodunuzu görünüyor böylece:

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

Bunun bir özelliği, diğer dökümleri de desteklemesidir (örneğin, ters yönde de çalışır).

Ayrıca Boost lexical_cast sadece bir dize akışına yazmaya başladıktan sonra akıştan geri çekilmesine rağmen, şimdi birkaç ekleme olduğunu unutmayın. Her şeyden önce, birkaç tür için uzmanlık eklenmiştir, bu nedenle birçok yaygın tür için, bir dize akışı kullanmaktan çok daha hızlıdır. İkincisi, şimdi sonucu kontrol eder, bu nedenle (örneğin) bir dizeden a dönüştürürseniz, dize bir dönüştürülemeyen bir intşey içeriyorsa bir istisna atabilir int(örneğin 1234başarılı olur, ancak 123abcatar) .

C ++ 11'den itibaren, std::to_stringtamsayı türleri için aşırı yüklenmiş bir işlev vardır, böylece aşağıdaki gibi kod kullanabilirsiniz:

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

İle dönüştürme yapmak için eşdeğer olarak tanımlamış, bu sprintf(örneğin nesnenin verilen türü, kibrit dönüşüm belirteci kullanarak %diçin intdaha sonra bir oluşturma, yeterli büyüklükte bir tampon içine) std::stringbu tamponun içindekiler.

Boost yüklediyseniz (yapmanız gerekir):

#include <boost/lexical_cast.hpp>

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

Dize akışlarını kullanmak daha kolay olurdu:

#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

Veya bir işlev yapın:

#include <sstream>

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

Bildiğim gibi değil, saf C ++. Ama bahsettiklerinizin biraz değiştirilmesi

string s = string(itoa(a));

çalışmalı ve oldukça kısa.

Matthieu M tarafından önerildiğistd::to_string gibi C ++ 11'de kullanabilirsiniz :

std::to_string(42);

Veya performans kritikse (örneğin, çok sayıda dönüşüm yaparsanız), bir tamsayıyı şuna dönüştürmek fmt::format_intiçin {fmt} kitaplığından kullanabilirsiniz std::string:

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

Veya bir C dizesi:

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

İkincisi dinamik bellek ayırma yapmaz ve std::to_stringBoost Karma kriterlerinden 10 kat daha hızlıdır . Daha fazla bilgi için bkz. C ++ 'da hızlı tamsayıdan dizeye dönüştürme .

Her ikisinin de iş parçacığı için güvenli olduğunu unutmayın.

Aksine std::to_string, fmt::format_intC ++ 11 gerektirmez ve herhangi bir C ++ derleyicisiyle çalışır.

Feragatname: {fmt} kütüphanesinin yazarıyım.

sprintf()biçim dönüştürme için oldukça iyidir. Ardından, ortaya çıkan C dizesini 1'de yaptığınız gibi C ++ dizesine atayabilirsiniz.

İlk olarak şunları içerir:

#include <string>
#include <sstream>

İkinci yöntemi ekleyin:

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

Bunun gibi bir yöntem kullanın:

NumberToString(69);

veya

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

Sayı dönüştürme için stringstream kullanmak tehlikelidir!

Biçimlendirilmiş çıktı eklediğini söyleyen http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ adresine bakın operator<<.

Geçerli yerel ayarınıza bağlı olarak 3 basamaktan büyük bir tam sayı, 4 basamaklı bir dizeye dönüşerek fazladan bir binlik ayırıcı ekleyebilir.

Örneğin, int = 1000bir dizeye dönüştürülebilir 1.001. Bu karşılaştırma işlemlerinin hiç çalışmamasına neden olabilir.

Bu yüzden std::to_stringyolu kullanmanızı şiddetle tavsiye ederim . Daha kolay ve beklediğiniz şeyi yapar.

Güncellenmiş (aşağıdaki yorumlara bakın) :

C ++ 17, std::to_charsdaha yüksek performanslı bir konumdan bağımsız alternatif olarak sunulur

C ++ 98 için birkaç seçenek vardır:

boost/lexical_cast

Boost, C ++ kütüphanesinin bir parçası değildir, ancak birçok yararlı kütüphane uzantısı içerir.

lexical_castFonksiyon şablonu ve onlar metin olarak temsil edilir keyfi türlerinden ortak dönüşümleri desteklemek için uygun ve tutarlı formu sunuyor.
- Boost Belgeleri

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

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

Çalışma zamanı gelince, lexical_castişlem ilk dönüşümde yaklaşık 80 mikrosaniye (makinemde) alır ve daha sonra yedekli olarak yapılırsa önemli ölçüde hızlanır.

itoa

Bu işlev ANSI-C'de tanımlanmamıştır ve C ++ 'ın bir parçası değildir, ancak bazı derleyiciler tarafından desteklenir.
- cplusplus.com

Bu, kodu kullanarak gcc/ g++derleyemeyeceğiniz anlamına gelir 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;
}

Rapor etmek için çalışma zamanı yok. Derlenmiş olduğu bildirilen Visual Studio yüklü değil itoa.

sprintf

sprintf C dizeleri üzerinde çalışan ve standart olarak mükemmel bir alternatif olan C standart kitaplık işlevidir.

Printf'de biçim kullanıldıysa yazdırılacak aynı metne sahip bir dize oluşturur, ancak yazdırılmak yerine, içerik str ile gösterilen arabellekte C dizesi olarak saklanır.
- 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.hBaşlık gerekli olmayabilir. sprintfÇalışma zamanına gelince, işlem ilk dönüşümde yaklaşık 40 mikrosaniye (makinemde) alır ve daha sonra yedekli olarak yapılırsa önemli ölçüde hızlanır.

stringstream

Bu, C ++ kitaplığının tamsayıları dizelere dönüştürmenin ana yoludur ve tersi de geçerlidir. stringstreamAkımın kullanım amacını daha da sınırlayan benzer kardeş işlevleri vardır ostringstream. Özellikle kullanmak ostringstream, kod okuyucusuna yalnızca <<operatörü kullanmak istediğinizi söyler . Bu işlev özellikle bir tamsayıyı dizeye dönüştürmek için gerekli olan tek şeydir. Daha ayrıntılı bir tartışma için bu soruya bakın .

#include <sstream>
#include <string>

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

Çalışma süresine gelince, ostringstreamişlem yaklaşık 71 mikrosaniye (makinemde) alır ve daha sonra yedekli olarak yapılırsa, ancak önceki işlevler kadar değil , önemli ölçüde hızlanır .

Tabii ki başka seçenekler de var ve bunlardan birini kendi işlevinize bile sarabilirsiniz, ancak bu popüler olanlardan bazılarına analitik bir bakış sunar.

C ++ 17, daha yüksek performanslı bir konumdan bağımsız alternatif olarak std :: to_chars sağlar .

Akarsu benzeri bir şekilde anında dizeler oluşturmanıza izin veren bazı sözdizimsel şeker eklemek oldukça kolaydır.

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

Artık (operatörün << (std::ostream& ..)bunun için tanımlanması koşuluyla) istediğinizi ekleyebilir strmake()ve yerine bir kullanabilirsiniz std::string.

Misal:

#include <iostream>

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

REDAKTE. Sabit bir sayıya sahip bir tamsayının '0' ile sola doldurulmuş char * ' a hızlı dönüştürülmesine ihtiyacınız varsa , bu küçük endian mimarileri (tümü x86, x86_64 ve diğerleri) için örnektir:

İki basamaklı bir sayıyı dönüştürüyorsanız:

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

Üç basamaklı bir sayıyı dönüştürüyorsanız:

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

Dört basamaklı bir sayıyı dönüştürüyorsanız:

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

Ve böylece yedi basamaklı sayılara kadar. Bu örnekte nbelirli bir tam sayı verilmiştir. Dönüşümden sonra dize temsiline şu şekilde erişilebilir (char*)&s:

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

NOT: Büyük endian bayt sırasına ihtiyacınız varsa, test etmedim, ancak burada bir örnek var: üç basamaklı sayı int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;için dört basamaklı sayılar içindir (64 bit kemer): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;Sanırım çalışması gerekir.

kullanın:

#define convertToString(x) #x

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

Kullanırım:

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

Windows ve Linux g ++ derleyicilerimde çalışır.

İşte yapmanın başka bir kolay yolu

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

sprintf gerekli formattaki bir dizeye veri eklemek için iyi bilinen bir bilgidir.

Bir char *diziyi üçüncü satırda gösterildiği gibi bir dizeye dönüştürebilirsiniz .

Bu benim için çalıştı -

Kodum:

#include <iostream>
using namespace std;

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

std::to_string()Sayısal türler için C ++ 11 tanıtıldı :

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

kullanın:

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

MFC kullanıyorsanız şunları kullanabilirsiniz 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));
    }
}

Şimdi kullanabilirsiniz to_string(5).

Bence stringstreamkullanımı oldukça kolay:

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

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

Bir dizeye dönüştürmek için sayaç tipi bir algoritma kullanırsınız. Bu tekniği Commodore 64 bilgisayarlarını programlayarak aldım . Oyun programlama için de iyidir.

• Tamsayıyı alırsınız ve 10'luk güçlerle ağırlıklandırılmış her basamağı alırsınız. Yani tamsayı 950 olduğunu varsayın.

  • Eğer tamsayı 100.000'e eşit veya 100.000'den büyükse, 100.000 değerini çıkarın ve dizedeki sayacı ["000000"] 'de artırın;
    100.000 konumunda daha fazla sayı kalmayıncaya kadar yapmaya devam edin. On güç daha düşür.

  • Tamsayı 10.000'e eşit veya 10'dan büyükse, 10.000 değerini çıkarın ve dizedeki sayacı ["000000"] + 1 konumunda artırın;
    10.000 konumunda daha fazla numara kalmayıncaya kadar yapmaya devam edin.

• On güç daha düşür

• Deseni tekrarlayın

950'nin örnek olarak kullanmak için çok küçük olduğunu biliyorum, ama umarım bu fikri anlarsınız.