Найпростіший спосіб перетворення int в рядок в C ++

Який найпростіший спосіб перетворити з intеквівалента stringв C ++. Мені відомі два методи. Чи є простіший спосіб?

(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, аналоги C 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 нарешті запропонував спосіб зробити оригінально-магнетичне рішення на основі макросу (збережене нижче), не проходячи через макро потворність.

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

Оригінальна відповідь:

Оскільки "перетворення ... у рядок" є повторюваною проблемою, я завжди визначаю макрос SSTR () у центральному заголовку моїх джерел C ++:

#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) і не потребує жодних сторонніх включень (якщо ви не можете використовувати Boost lexical_cast<>); оба ці інші рішення мають кращу продуктивність.

Зазвичай я використовую наступний метод:

#include <sstream>

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

Це детально описано тут .

Мабуть, найпоширеніший простий спосіб перетворює по суті ваш другий вибір у названий шаблон lexical_cast, наприклад, у Boost , тому ваш код виглядає так:

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

Одна з причин цього полягає в тому, що він підтримує і інші ролі (наприклад, у зворотному напрямку працює так само добре).

Також зауважте, що хоча Boost lexical_cast почався як просто запис у потоковий струм, а потім витяг із потоку назад, тепер він має кілька доповнень. Перш за все, додані спеціалізації для досить кількох типів, тому для багатьох поширених типів це значно швидше, ніж використання потокового потоку. По-друге, тепер перевіряє результат, тому (наприклад), якщо ви перетворюєте з рядка в 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вміст цього буфера.

Якщо у вас встановлено Boost (який слід):

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

Або рядок C:

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

Останній не здійснює динамічного розподілу пам’яті і є більш ніж у 10 разів швидшим, ніж std::to_stringна показниках Boost Karma. Детальнішу інформацію див. У розділі Швидке перетворення цілих чисел у C ++ .

Зверніть увагу, що обидва є безпечними для потоків.

На відміну від цього std::to_string, fmt::format_intне вимагає C ++ 11 і працює з будь-яким компілятором C ++.

Відмова: Я автор бібліотеки {fmt}.

sprintf()досить добре для перетворення формату. Потім ви можете призначити отриманий рядок C рядку C ++, як це було зроблено в 1.

Спочатку включайте:

#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!."

Використання stringstream для перетворення чисел небезпечно!

Див. Http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/, де вказується, що operator<<вставляє відформатований вихід.

Залежно від вашого поточного локального значення, ціле число, що перевищує 3 цифри, може перетворити на рядок у 4 цифри, додавши додатковий роздільник тисяч.

Наприклад, int = 1000може бути перетворений на рядок 1.001. Це може змусити порівняльні операції взагалі не працювати.

Тому я настійно рекомендую скористатися цим std::to_stringспособом. Це простіше і робить те, що ви очікуєте.

Оновлено (див. Коментарі нижче) :

C ++ 17 є std::to_charsальтернативою, що не відрізняється місцевою ефективністю

Для C ++ 98 є кілька варіантів:

boost/lexical_cast

Boost не є частиною бібліотеки C ++, але містить багато корисних розширень бібліотеки.

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

Немає часу виконання звіту. У мене немає встановленої Visual Studio, яку, як повідомляється, можна компілювати itoa.

sprintf

sprintf є стандартною функцією бібліотеки С, яка працює на C рядках, і є абсолютно вірною альтернативою.

Складає рядок з тим самим текстом, який був би надрукований, якби формат був використаний на printf, але замість того, щоб друкувати, вміст зберігається як рядок C у буфері, вказаному 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;
}

stdio.hЗаголовок не може бути необхідним. Що стосується часу виконання, то sprintfоперація займає близько 40 мікросекунд (на моїй машині) при першому перетворенні, а потім значно пришвидшується після цього, якщо це робиться надмірно.

stringstream

Це основний спосіб бібліотеки C ++ перетворення цілих чисел у рядки, і навпаки. Існують подібні сестринські функції, stringstreamякі додатково обмежують використання потоку, як-от ostringstream. ostringstreamСпеціальне використання повідомляє читачеві вашого коду, що ви тільки маєте намір використовувати <<оператор. Ця функція - це все, що особливо необхідно для перетворення цілого числа в рядок. Дивіться це питання для більш детальної дискусії.

#include <sstream>
#include <string>

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

Що стосується часу виконання, то ця ostringstreamоперація займає близько 71 мікросекунди (на моїй машині), а потім значно пришвидшується, якщо виконувати зайве, але не на стільки, скільки попередні функції .

Звичайно, є й інші варіанти, і ви навіть можете включити один із них у свою функцію, але це пропонує аналітичний погляд на деякі популярні.

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

ВИДАЛЕНО. Якщо вам потрібно швидко перетворити ціле число з фіксованою кількістю цифр у char * з лівою підкладкою '0' , це приклад для архітектур малої ендіанської архітектури (всі 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();

Він працює на моїх компіляторах g ++ для Windows та Linux.

Ось ще один простий спосіб зробити

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

C ++ 11, введений std::to_string()для числових типів:

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

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

Для перетворення в рядок ви використовуєте лічильний тип алгоритму. Я отримав цю техніку з програмування комп'ютерів Commodore 64 . Це також добре для ігрового програмування.

• Ви берете ціле число і приймаєте кожну цифру, зважену потужностями 10. Отже, припустимо, ціле число дорівнює 950.

  • Якщо ціле число дорівнює або перевищує 100 000, віднімаємо 100 000 і збільшуємо лічильник у рядку на ["000000"];
    продовжуйте робити це до тих пір, поки не буде більше цифр на позиції 100 000. Відкиньте ще одну потужність десять.

  • Якщо ціле число дорівнює або перевищує 10 000, віднімаємо 10000 і збільшуємо лічильник у рядку в позиції ["000000"] + 1;
    продовжуйте робити це, поки не буде більше цифр у позиції 10 000.

• Відкиньте ще одну потужність десять

• Повторіть візерунок

Я знаю, що 950 занадто малий, щоб використовувати його як приклад, але я сподіваюся, що ви зрозумієте цю ідею.