C ++ හි int එක string බවට පරිවර්තනය කිරීමට පහසුම ක්‍රමය

C ++ හි intසමාන සිට සමාන බවට පරිවර්තනය කිරීමට ඇති පහසුම ක්‍රමය කුමක්ද? stringමම ක්‍රම දෙකක් ගැන දන්නවා. පහසු ක්‍රමයක් තිබේද?

(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(හා එක් එක් සංඛ්යා වර්ගය සඳහා ප්රභේද්යයන්) සහ std::to_string, සී යන සගයන් atoiහා itoaනමුත් කාලීන ප්රකාශ std::string.

#include <string> 

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

ඒ නිසා මට සිතිය හැකි කෙටිම ක්‍රමයයි. යතුරුපදය භාවිතා කරමින් ඔබට වර්ගය නම් කිරීම පවා අතහැර දැමිය හැකිය auto:

auto s = std::to_string(42);

සටහන: බලන්න [string.conversions] ( 21.5 දී n3242 )

වසර කිහිපයකට පසු @ v.oddou සමඟ සාකච්ඡාවක් ආරම්භ කරමින්, C ++ 17 අවසාන වශයෙන් සාර්ව අවලස්සන තත්වයට පත් නොවී මුලින් සාර්ව මත පදනම් වූ වර්ග-අ nost ෙයවාදී විසඳුමක් (පහත සංරක්ෂණය කර ඇති) කිරීමට ක්‍රමයක් ලබා දී ඇත.

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

භාවිතය:

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 ++ ප්‍රභවයන්ගේ කේන්ද්‍රීය ශීර්ෂයක SSTR () සාර්ව අර්ථ දක්වන්නෙමි :

#include <sstream>

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

භාවිතය හැකි තරම් පහසු ය:

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 ++ 98 අනුකූල වේ (ඔබට C ++ 11 භාවිතා කළ නොහැකි නම් std::to_string), සහ කිසිදු තෙවන පාර්ශවයකට ඇතුළත් කිරීම අවශ්‍ය නොවේ (ඔබට බූස්ට් භාවිතා කළ නොහැකි නම් lexical_cast<>); මෙම අනෙක් විසඳුම් දෙකම වඩා හොඳ කාර්ය සාධනයක් ඇත.

මම සාමාන්‍යයෙන් පහත ක්‍රමය භාවිතා කරමි:

#include <sstream>

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

එය මෙහි විස්තරාත්මකව විස්තර කර ඇත .

බොහෝ විට වඩාත් පහසු පහසුම ක්‍රමය වන්නේ ඔබේ දෙවන තේරීම බූස්ට්lexical_cast වැනි අච්චුවකට අත්‍යවශ්‍යයෙන්ම එතීමයි , එබැවින් ඔබේ කේතය මේ ආකාරයෙන් පෙනේ:

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

මෙහි ඇති එක් හොඳ කරුණක් නම්, එය අනෙක් කාස්ට් සඳහා ද සහාය වීමයි (උදා: ප්‍රතිවිරුද්ධ දිශාවට ද ක්‍රියා කරයි).

බූස්ට් ලෙක්සිකල්_කාස්ට් ආරම්භ වූයේ හුදෙක් සංගීත ප්‍රවාහයකට ලිවීමෙන් පසුව, ධාරාවෙන් පිටතට උපුටා ගැනීමක් වුවද, දැන් එයට එකතු කිරීම් කිහිපයක් ඇති බව සලකන්න. පළමුවෙන්ම, වර්ග කිහිපයක් සඳහා විශේෂීකරණයන් එකතු කර ඇත, එබැවින් බොහෝ පොදු වර්ග සඳහා, එය නූල් ප්‍රවාහයක් භාවිතා කිරීමට වඩා සැලකිය යුතු වේගයකින් යුක්ත වේ. දෙවනුව, එය දැන් ප්‍රති result ලය පරික්ෂා කරයි, එබැවින් (නිදසුනක් ලෙස) ඔබ නූලක සිට අ බවට පරිවර්තනය කරන්නේ නම් int, එය බවට පරිවර්තනය කළ නොහැකි යමක් එම නූලෙහි තිබේ නම් එය ව්‍යතිරේකයක් විසි කළ හැකිය int(උදා: 1234සාර්ථක වනු ඇත, නමුත් 123abcවිසි කරයි) .

C ++ 11 වන විට, std::to_stringපූර්ණ සංඛ්‍යා වර්ග සඳහා අධික ලෙස පටවා ඇති ශ්‍රිතයක් ඇත, එබැවින් ඔබට පහත පරිදි කේත භාවිතා කළ හැකිය:

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

ප්‍රමිතිය මේවා අර්ථ දක්වන්නේ sprintf(සැපයූ වස්තුවට ගැලපෙන පරිවර්තන පිරිවිතර භාවිතා කිරීම %dසඳහා int), ප්‍රමාණවත් ප්‍රමාණයේ බෆරයක් බවට පරිවර්තනය කර එම බෆරයේ std::stringඅන්තර්ගතයෙන් එකක් සෑදීම සඳහාය.

ඔබ බූස්ට් ස්ථාපනය කර ඇත්නම් (ඔබ කළ යුත්තේ එයයි):

#include <boost/lexical_cast.hpp>

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

සංගීත ප්‍රවාහ භාවිතා කිරීම පහසු වනු ඇත:

#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

නැතහොත් ශ්‍රිතයක් කරන්න:

#include <sstream>

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

පිරිසිදු C ++ වලින් මා දන්නා දෙයක් නොවේ. නමුත් ඔබ සඳහන් කළ දෙයෙහි සුළු වෙනස් කිරීමක්

string s = string(itoa(a));

වැඩ කළ යුතු අතර එය ඉතා කෙටි ය.

මැතිව් එම් විසින් යෝජනා කළstd::to_string පරිදි ඔබට C ++ 11 හි භාවිතා කළ හැකිය :

std::to_string(42);

හෝ, කාර්ය සාධනය ඉතා වැදගත් වේ නම් (උදාහරණයක් ලෙස, ඔබ ආගමට හරවා ගොඩක් කරන්න නම්), ඔබ භාවිතා කළ හැකිය fmt::format_intසිට {fmt} පුස්තකාලයට යනු පූර්ණ සංඛ්යාවකි බවට පරිවර්තනය කිරීමට std::string:

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

හෝ සී නූලක්:

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

දෙවැන්න කිසිදු ගතික මතක වෙන් කිරීමක් නොකරන අතර එය std::to_stringබූස්ට් කර්මා මිණුම් සලකුණු වලට වඩා 10 ගුණයකින් වේගවත් වේ . බලන්න C ++, සංගීත පරිවර්තනය තදින් පූර්ණ සංඛ්යාමය වැඩි විස්තර සඳහා.

දෙකම නූල් ආරක්ෂිත බව සලකන්න.

මෙන් නොව std::to_string, fmt::format_intC ++ 11 අවශ්‍ය නොවන අතර ඕනෑම C ++ සම්පාදකයෙකු සමඟ ක්‍රියා කරයි.

වියාචනය: මම {fmt} පුස්තකාලයේ කතුවරයා වෙමි.

sprintf()ආකෘති පරිවර්තනය සඳහා සෑහෙන්න හොඳයි. එවිට ඔබට 1 හි සිදු කළ පරිදි C ++ නූලට ප්‍රති C ලයක් ලෙස C නූල පැවරිය හැකිය.

පළමුව ඇතුළත් කරන්න:

#include <string>
#include <sstream>

දෙවනුව ක්රමය එකතු කරන්න:

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

මේ වගේ ක්‍රමය භාවිතා කරන්න:

NumberToString(69);

හෝ

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

අංක පරිවර්තනය සඳහා නූල් ප්‍රවාහය භාවිතා කිරීම භයානකයි!

බලන්න http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ එය කියයි එහිදීoperator<< ආකෘතිගත ප්‍රතිදානය ඇතුළු කරන වේ.

ඔබගේ වර්තමාන පෙදෙසි මත පදනම්ව, ඉලක්කම් 3 ට වඩා වැඩි සංඛ්‍යාවක්, ඉලක්කම් 4 ක නූලකට පරිවර්තනය කළ හැකි අතර අමතර දහස් ගණනක් බෙදුම්කරු එකතු කරයි.

උදා, නූලකට int = 1000පරිවර්තනය කළ හැකිය 1.001. මෙය සැසඳීමේ මෙහෙයුම් කිසිසේත් ක්‍රියාත්මක නොවන බවට පත් කළ හැකිය.

එබැවින් std::to_stringමාර්ගය භාවිතා කිරීමට මම තරයේ නිර්දේශ කරමි . එය පහසු වන අතර ඔබ අපේක්ෂා කරන දේ කරයි.

යාවත්කාලීන කරන ලදි (පහත අදහස් බලන්න) :

සී ++ 17 std::to_charsඉහළ කාර්යසාධනයක් සහිත ස්ථාන-ස්වාධීන විකල්පයක් ලෙස සපයයි

C ++ 98 සඳහා , විකල්ප කිහිපයක් තිබේ:

boost/lexical_cast

බූස්ට් යනු සී ++ පුස්තකාලයේ කොටසක් නොවේ, නමුත් බොහෝ ප්‍රයෝජනවත් පුස්තකාල දිගු අඩංගු වේ.

මෙම lexical_castකාර්යය සැකිල්ල අත්තනෝමතික වර්ග යාමට සහ එහි සිට පොදු පරිවර්ථනයන් සහාය ඔවුන් පෙළ ලෙස නියෝජනය කරන විට සඳහා පහසු සහ ස්ථිරසාර ආකෘති පත්රය ඉදිරිපත් කරයි.
- බූස්ට්ගේ ලියකියවිලි

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

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

ධාවන කාලය සඳහා, lexical_castමෙහෙයුම පළමු පරිවර්තනය සඳහා මයික්‍රෝ තත්පර 80 ක් (මගේ යන්ත්‍රයේ) ගත වන අතර, පසුව අතිරික්තව සිදු කළ හොත් සැලකිය යුතු වේගයකින් පසුව වේගවත් වේ.

itoa

මෙම ශ්‍රිතය ANSI-C හි අර්ථ දක්වා නොමැති අතර එය C ++ හි කොටසක් නොවේ, නමුත් සමහර සම්පාදකයින්ගේ සහාය ඇත.
- cplusplus.com

මෙයින් අදහස් කරන්නේ gcc/ g++භාවිතා කර කේත සම්පාදනය කළ නොහැකි 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;
}

වාර්තා කිරීමට ධාවන කාලයක් නොමැත. මට දෘශ්‍ය ස්ටුඩියෝ ස්ථාපනය කර නැත, එය සම්පාදනය කළ හැකි බව වාර්තා වේ itoa.

sprintf

sprintf සී සම්මත පුස්තකාල ශ්‍රිතයක් වන අතර එය සී නූල් මත ක්‍රියා කරයි.

Printf හි ආකෘතිය භාවිතා කර ඇත්නම් මුද්‍රණය කරනු ලබන එකම පෙළක් සහිත නූලක් රචනා කරයි, නමුත් මුද්‍රණය කරනවා වෙනුවට අන්තර්ගතය str මඟින් පෙන්වා ඇති බෆරයේ C string ලෙස ගබඩා වේ.
- 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.hශීර්ෂ අවශ්ය විය හැක. ධාවන කාලය සඳහා, sprintfමෙහෙයුම පළමු පරිවර්තනය සඳහා මයික්‍රෝ තත්පර 40 ක් (මගේ යන්ත්‍රයේ) ගත වන අතර, පසුව අතිරික්තව සිදු කළ හොත් සැලකිය යුතු වේගයකින් පසුව වේගවත් වේ.

stringstream

පූර්ණ සංඛ්‍යා නූල් බවට පරිවර්තනය කිරීමේ සී ++ පුස්තකාලයේ ප්‍රධාන ක්‍රමය මෙය වන අතර අනෙක් අතට. stringstreamප්‍රවාහයට අපේක්ෂිත භාවිතය තවදුරටත් සීමා කිරීමට සමාන සහෝදර කාර්යයන් ඇත ostringstream. භාවිතා ostringstreamකිරීම ඔබේ කේතය පා the කයාට පවසන්නේ ඔබ <<ක්‍රියාකරු භාවිතා කිරීමට පමණක් අදහස් කරන බවයි. මෙම ශ්‍රිතය පූර්ණ සංඛ්‍යාවක් නූලකට පරිවර්තනය කිරීම සඳහා විශේෂයෙන් අවශ්‍ය වේ. වඩාත් සවිස්තරාත්මක සාකච්ඡාවක් සඳහා මෙම ප්‍රශ්නය බලන්න .

#include <sstream>
#include <string>

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

ධාවන කාලය සම්බන්ධයෙන් ගත් කල, ostringstreamමෙහෙයුම මයික්‍රෝ තත්පර 71 ක් (මගේ යන්ත්‍රය මත) ගත වන අතර, පසුව අතිරික්තව සිදු කළ හොත් සැලකිය යුතු වේගයකින් පසුව වේගවත් වේ, නමුත් පෙර කාර්යයන් තරම් නොවේ .

ඇත්ත වශයෙන්ම වෙනත් විකල්ප තිබේ, ඔබට මේවායින් එකක් ඔබේම ක්‍රියාකාරිත්වයට ඔතා ගත හැකිය, නමුත් මෙය සමහර ජනප්‍රිය ඒවා විශ්ලේෂණාත්මක පෙනුමක් ලබා දෙයි.

සී ++ 17 std::to_charsඉහළ කාර්යසාධනයක් සහිත ස්ථාන-ස්වාධීන විකල්පයක් ලෙස සපයයි .

කෙනෙකුට මැස්ස මත නූල් රචනා කිරීමට ඉඩ සලසන සින්ටැක්ටිකල් සීනි ටිකක් එකතු කිරීම තරමක් පහසුය

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

දැන් ඔබට අවශ්‍ය ඕනෑම දෙයක් එකතු කළ හැකිය (ඒ සඳහා ක්‍රියාකරුවෙකු << (std::ostream& ..)අර්ථ දක්වා තිබේ නම්) strmake()ඒ වෙනුවට එය භාවිතා කළ හැකිය std::string.

උදාහරණයක්:

#include <iostream>

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

සංස්කරණය කරන ලදි. ඔබට අවශ්ය නම් වේගයෙන් සමඟ පූර්ණ සංඛ්යාවක් බවට පරිවර්තනය ඉලක්කම් ස්ථාවර අංකය * කටු කිරීමට ඉතිරි-ආවරණයකින් සමන්විත '0' සමග , මේ පුංචි-endian ආකෘතීන් (සියළුම x86, x86_64 සහ වෙනත් අය) සඳහා උදාහරණයක්:

ඔබ ඉලක්කම් දෙකක අංකයක් පරිවර්තනය කරන්නේ නම්:

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

ඔබ ඉලක්කම් තුනක අංකයක් පරිවර්තනය කරන්නේ නම්:

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

ඔබ ඉලක්කම් හතරක අංකයක් පරිවර්තනය කරන්නේ නම්:

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

අංක හත දක්වා සංඛ්‍යා එසේ වේ. මෙම උදාහරණයේ nදී දී ඇති පූර්ණ සංඛ්‍යාවක් ඇත. පරිවර්තනය කිරීමෙන් පසු එහි නූල් නිරූපණය පහත පරිදි ප්‍රවේශ කළ හැකිය (char*)&s:

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

සටහන: ඔබට එය විශාල-එන්ඩියන් බයිට් අනුපිළිවෙලින් අවශ්‍ය නම්, මම එය අත්හදා බැලුවේ නැත, නමුත් මෙන්න උදාහරණයක්: ඉලක්කම් තුනේ අංකයක් සඳහා එය int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;ඉලක්කම් හතරේ අංක සඳහා (බිට් 64 ආරුක්කු) වේ: int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;එය ක්‍රියාත්මක විය යුතු යැයි මම සිතමි.

භාවිත:

#define convertToString(x) #x

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

මම භාවිතා කරන්නේ:

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

එය මගේ වින්ඩෝස් සහ ලිනක්ස් ජී ++ සම්පාදක මත ක්‍රියා කරයි.

මෙන්න තවත් පහසු ක්‍රමයක්

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

sprintf ඕනෑම දත්තයක් අවශ්‍ය ආකෘතියේ නූලකට ඇතුළු කිරීම සඳහා ප්‍රසිද්ධ එකක්.

char *තෙවන පේළියේ පෙන්වා ඇති පරිදි ඔබට අරාව නූල් බවට පරිවර්තනය කළ හැකිය .

මෙය මට වැඩ කළා -

මගේ කේතය:

#include <iostream>
using namespace std;

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

std::to_string()සංඛ්‍යාත්මක වර්ග සඳහා හඳුන්වා දුන් සී ++ 11 :

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

භාවිත:

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

int i = 255; std::string s = std::to_string(i);

C ++ හි, to_string () මඟින් අක්ෂර අනුක්‍රමයක් ලෙස අගය නිරූපණය කිරීමෙන් පූර්ණ සංඛ්‍යා අගයේ තන්තු වස්තුවක් නිර්මාණය වේ.

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 භාවිතා කරන්නේ නම් , ඔබට මෙය භාවිතා කළ හැකිය 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));
    }
}

ඔබට දැන් භාවිතා කළ හැකිය to_string(5).

මම හිතන්නේ භාවිතා stringstreamකිරීම පහසුයි:

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

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

නූලකට පරිවර්තනය කිරීම සඳහා ඔබ ප්‍රති-ඇල්ගොරිතම වර්ගයක් භාවිතා කරයි. මට මෙම තාක්ෂණය ලැබුණේ කොමඩෝර් 64 පරිගණක ක්‍රමලේඛයෙන් . එය ක්‍රීඩා වැඩසටහන් සඳහා ද හොඳ ය.

• ඔබ නිඛිලය ගෙන 10 බලයෙන් බර වන සෑම අංකයක්ම ගන්න. එබැවින් නිඛිලය 950 යැයි උපකල්පනය කරන්න.

  • නිඛිලය සමාන හෝ 100,000 ට වඩා වැඩි නම් 100,000 අඩු කර ["000000"] නූලෙහි කවුන්ටරය වැඩි කරන්න;
    100,000 ස්ථානයේ තවත් සංඛ්‍යාවක් නොමැති තෙක් එය දිගටම කරගෙන යන්න. තවත් දහයක බලයක් අතහරින්න.

  • නිඛිලය සමාන හෝ 10,000 ට වඩා වැඩි නම් 10,000 අඩු කර නූලෙහි කවුන්ටරය ["000000"] + 1 ස්ථානයේ වැඩි කරන්න;
    10,000 වන ස්ථානයේ තවත් සංඛ්‍යාවක් නොමැති තෙක් එය දිගටම කරගෙන යන්න.

• තවත් දහයක බලයක් අතහරින්න

• රටාව නැවත කරන්න

950 උදාහරණයක් ලෙස භාවිතා කිරීමට නොහැකි තරම් කුඩා බව මම දනිමි, නමුත් ඔබට අදහස ලැබෙනු ඇතැයි මම බලාපොරොත්තු වෙමි.