29 Вопрос: Самый простой способ конвертировать int в строку в C ++

вопрос создан в Tue, Apr 10, 2018 12:00 AM

Какой самый простой способ конвертировать из 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();
    
1400
  1. Я думаю, что оба предоставленных вами метода являются хорошими решениями. это зависит от контекста, где вам нужно это сделать. Если вы уже работаете с потоками, например, читаете или пишете файл, тогда ваш второй метод - лучший. Если вам нужно передать int как строку в аргумент функции, то itoa может быть простым способом. Но в большинстве случаев при работе с файлами происходит преобразование int в строку, поэтому потоки подходят.
    2011-04-08 05: 21: 58Z
  2. Как вариант 1 вообще работает для вас? Насколько я понимаю, itoa() принимает три параметра.
    2013-04-10 02: 49: 52Z
  3. это будет быстрее, чем эквивалент потока. Существуют также способы повторного использования строкового буфера с помощью метода itoa (избегая выделения кучи, если вы часто генерируете строки. Например, для некоторых быстро обновляемых числовых выходных данных). В качестве альтернативы вы можете сгенерировать пользовательский поток потоков, чтобы уменьшить некоторые накладные расходы и т. Д. Построение потока в первую очередь также не является недорогим предприятием.
    2013-08-28 18: 46: 15Z
  4. @ Пит: Как только вы начнете беспокоиться о том, что быстрее, вам нужно взглянуть на stackoverflow.com/questions/4351371/…
    2013-09-24 19: 21: 53Z
  5. Обратите внимание, что itoa () не является частью стандарта, и поэтому его использование делает ваш код непереносимым, поскольку не все компиляторы поддерживают его. Для Linux вы наверняка отсутствуют, если вы не используете что-то еще, кроме GCC, который не поддерживает эту функцию. Если у вас есть C ++ 0x, используйте то, что @Matthieu предложил в своем ответе. Если это не так, используйте stringstream, поскольку это хорошо поддерживаемая функция, и ваш код должен быть совместим с любым компилятором C ++. В качестве альтернативы вы всегда можете использовать sprintf ().
    2014-06-16 09: 59: 55Z
29 ответов                              29                         

C ++ 11 представляет std::stoi (и варианты для каждого числа type) и 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 )

    
1855
2018-03-14 20: 51: 32Z
  1. to_string не является членом исправления std: stackoverflow.com/questions/12975341/…
    2012-11-02 03: 02: 19Z
  2. Или, в зависимости от вашего компилятора, просто установите правильный языковой стандарт: g++ -std=c++11 someFile.cc
    2012-11-29 23: 12: 13Z
  3. @ Steve: так и должно быть. Это член std во всех известных мне компиляторах, кроме одного.
    2013-05-31 21: 34: 33Z
  4. @ Matthiew M. Я использую то же, что вы предлагаете, но я получаю эту ошибку: Error : No instance of overloaded function "std::to_string" matches the argument list я использую VS2010 c ++
    2013-09-26 13: 51: 33Z
  5. @ Flying: в VS2010 вы должны явным образом преобразовать целое число преобразования в один из следующих типов [_Longlong, _ULonglong, long double]; то есть: string s = to_string((_ULonglong)i);
    2013-12-06 14: 50: 12Z

Пару лет спустя после обсуждения с @ 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<>); оба эти решения имеют лучшую производительность.

    
180
2018-12-05 12: 48: 38Z
  1. Я не очень знаком с dynamic_cast, но я использую clang для компиляции, поэтому он жалуется на это. Если я просто опускаю dynamic_cast, то он прекрасно компилируется; какой цели служит dynamic_cast в этом случае? Мы уже создаем ostringstream, так зачем его разыгрывать?
    2014-10-21 02: 38: 35Z
  2. @ Мэтью: ссылка в моем ответе приводит к подробному описанию каждой части конструкции. В то время как мы создали ostringstream, мы вызвали operator<<() для него, что возвращает ostream & - для которого .str() не определено. Мне действительно интересно, как clang сделал бы эту работу без приведения (или почему он генерирует ошибку с ним). Эта конструкция публикуется во многих местах, и я уже более десяти лет использую ее на многих различных компиляторах, включая MSVC, GCC и XLC, поэтому я довольно удивлен, что она не справляется.
    2014-10-21 06: 59: 31Z
  3. Просто пришли на вечеринку из любопытства и понизили голос. Причина: слишком много голосов за решение, которое не элегантно и, вероятно, медленно. 1. использование макроса. Я систематически не осуждаю какой-либо макрос, но этот слишком короткий, и конечные клиенты всегда боятся повторения аргумента, в дополнение к страху за незащищенные многоканальные макросы. (не защищено do {} while (0)) 2. dynamic_cast. кажется, вам нужен только static_cast, если вы не хотите утверждать, что библиотека действительно реализована так, как вы надеетесь. в этом случае вы должны использовать boost :: polymorphic_downcast вместо этого.
    2015-06-18 03: 30: 48Z
  4. @ v.oddou: Вы можете критиковать, конечно. Но 1. недействителен - макрос является одним оператором, do { } while( 0 ) ничего бы не добавил. С 2. и 3. Вы, вероятно, получили точку зрения - это можно сделать с помощью статического приведения, и, возможно, один из ваших мастеров шаблонов мог бы придумать «более приятный» интерфейс. Но, как я уже сказал, это ни в коем случае не выдумка меня самого. Посмотрите вокруг, этот макрос (макрос!) Довольно вездесущ. Это случай ПОЛА сам по себе. Я мог бы немного поиграть с этим, чтобы сделать его более «обтекаемым».
    2015-06-18 08: 45: 47Z
  5. @ v.oddou: посмотрите, что я нашел среди того, что принес нам C ++ 17. :-) Надеюсь, вам понравился обновленный ответ.
    2018-05-13 20: 57: 29Z

Я обычно использую следующий метод:

 
#include <sstream>

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

Подробно это описано здесь .

    
103
2019-05-31 12: 03: 17Z
  1. Перед использованием ss вам необходимо ss.clear(). Я видел неожиданные результаты без этой инициализации.
    2015-06-09 02: 48: 15Z
  2. @ lifebalance: такого поведения я никогда не видел.
    2015-06-11 08: 23: 56Z
  3. @ lifebalance: вам не нужно clear() вновь созданного объекта ostringstream. clear() сбрасывает флаги error /eof, и еще не было создано ни одного условия error /eof.
    2015-08-05 04: 00: 21Z
  4. Вы когда-либо пробовали это с char ?
    2016-05-31 12: 31: 16Z
  5. @ Расул NumberToString(23213.123) производит 23213.1, а std::to_string(23213.123) - 23213.123000 Что там происходит?
    2017-11-05 23: 00: 16Z

Вероятно, наиболее распространенный простой способ - это, по сути, ваш второй выбор в шаблон с именем lexical_cast, например, в Boost , поэтому ваш код выглядит следующим образом:

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

Одним из достоинств этого является то, что он поддерживает и другие приведения (например, в обратном направлении работает так же хорошо).

Также обратите внимание, что хотя Boost lexical_cast начинался с простой записи в поток строк, а затем извлекался из потока, теперь у него есть пара дополнений. Прежде всего, были добавлены специализации для нескольких типов, поэтому для многих распространенных типов это значительно быстрее, чем использование stringstream. Во-вторых, теперь он проверяет результат, поэтому (например), если вы преобразуете строку в int, она может выдать исключение, если строка содержит что-то, что не может быть преобразовано в int (например, 1234 будет успешным, но 123abc бросил бы).

Начиная с C ++ 11, функция std::to_string перегружена для целочисленных типов, поэтому вы можете использовать такой код:

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

Стандарт определяет их как эквивалентное выполнению преобразования с sprintf (с использованием спецификатора преобразования, который соответствует предоставленному типу объекта, например %d для int), в буфер достаточного размера, а затем создание std::string содержимого этого буфера.

    
85
2015-01-29 21: 36: 31Z
  1. Отлично, я предпочитаю ответ Кевина, хотя он показывает пространство имен include и. Просто незначительный захват. :) Хорошая работа, хотя!
    2013-03-21 14: 15: 55Z
  2. Я бы сказал, что это путь, если у вас нет поддержки C ++ 11.
    2013-06-21 08: 16: 02Z

Если у вас установлен Boost (что и нужно):

 
#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);
    
41
2011-04-08 04: 26: 01Z
  1. Согласился на ускоренную установку. Я думаю, что более часто можно было бы отформатировать строку. Для этой цели я предпочитаю boost :: format например, формат ("% 02d", число) .str ()
    2013-08-28 18: 47: 10Z

Было бы проще использовать строковые потоки:

 
#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();
}
    
28
2019-05-31 12: 05: 42Z

Не то, что я знаю, в чистом C ++. Но небольшая модификация того, что вы упомянули

 
string s = string(itoa(a));

должно работать, и оно довольно короткое.

    
19
2011-04-08 04: 22: 15Z
  1. itoa() не является стандартной функцией!
    2012-11-15 11: 25: 37Z
  2. @ cartoonist: Тогда что это?
    2012-11-15 15: 35: 43Z
  3. Эта функция не определена в ANSI-C и C ++. Так что это не поддерживается некоторым компилятором, таким как g ++.
    2012-11-15 20: 49: 38Z

sprintf() довольно хорош для преобразования формата. Затем вы можете назначить полученную строку C строке C ++, как вы это делали в 1.

    
16
2012-12-07 15: 59: 31Z
  1. и надеюсь, что используемый вами буфер достаточно велик ...
    2011-04-08 06: 14: 19Z
  2. Хех, да. Тем не менее, я обычно полагаюсь на snprintf () и друзей при обработке строк C.
    2011-04-08 12: 42: 58Z
  3. @ MatthieuM. Ваш комментарий далее доказывает, что вы не. Если выходные данные были усечены из-за этого ограничения, тогда возвращаемое значение - это количество символов (исключая завершающий нулевой байт), которое было бы записано в конечную строку, если бы было достаточно места. Таким образом, возвращаемое значение размера или более означает, что вывод был усечен. Поэтому вы называете его с NULL и нулевым размером, чтобы получить необходимый размер буфера.
    2013-09-25 08: 02: 48Z
  4. @ user1095108: я думаю, что вы ошибаетесь в snprintf (обратите внимание на префикс SNP ) и sprintf (обратите внимание на SP префикс). Вы передаете размер первому, и он заботится о том, чтобы не переполниться, однако последний не знает размер буфера и, таким образом, может переполниться.
    2013-09-25 09: 37: 04Z
  5. Идея состоит в том, чтобы сначала вызвать вариант snprintf, а затем вариант sprintf. Поскольку размер буфера к тому времени станет известен, вызов sprintf станет полностью безопасным.
    2013-09-25 09: 40: 38Z

Вы можете использовать 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}.

    
13
2019-05-31 12: 10: 04Z
  1. Это безопасно для потока?
    2014-06-16 20: 48: 48Z
  2. @ Сорен: Да, это потокобезопасно.
    2014-06-16 21: 02: 28Z
  3. Мне было любопытно, что у меня нет динамического выделения памяти, хотя он остается потокобезопасным (повторно входящим), поэтому я прочитал ваш код - c_str() возвращает указатель на буфер, объявленный внутри класса fmt::FormatInt - поэтому возвращаемый указатель будет недействительным в точке с запятой - см. также stackoverflow.com/questions/4214153/lifetime-of-temporaries
    2014-06-16 22: 17: 00Z
  4. Да, то же поведение, что и с std::string::c_str() (таким образом, именование). Если вы хотите использовать его за пределами полного выражения, создайте объект FormatInt f(42);. Тогда вы можете использовать f.c_str() без опасности его уничтожения.
    2014-06-16 23: 40: 52Z
  5. Я получаю что-то странное, когда пытаюсь преобразовать int в строку, используя std :: to_string (num). Если я сохраню результат в переменной и попытаюсь получить к нему доступ как stringNum [1] или stringNum [n] при увеличении n, я получаю мусор.
    2018-02-09 07: 25: 32Z

Сначала включите:

 
#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!."
    
12
2014-08-26 10: 29: 50Z

Для C ++ 98 есть несколько вариантов:

boost/lexical_cast

Boost не является частью библиотеки C ++, но содержит много полезных расширений библиотеки.

  

Шаблон функции lexical_cast предлагает удобную и согласованную форму для поддержки общих преобразований в и из произвольных типов, когда они представлены в виде текста.
  - Документация 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;
}

Что касается времени выполнения, операция 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, которая работает со строками 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 микросекунды (на моей машине), а затем значительно ускоряется, если выполняется с избыточностью, но не так сильно, как предыдущие функции .

Конечно, есть и другие варианты, и вы можете даже включить один из них в свои собственные функции, но это предлагает аналитический взгляд на некоторые из популярных.

    
8
2017-06-20 14: 58: 14Z
  1. Спасибо за заботу о нас (пользователи C ++ 98)
    2018-04-19 00: 47: 17Z

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

См. http://www.cplusplus.com/reference/ostream /ostream /operator% 3C% 3C / где он сообщает, что operator<< вставляет форматированный вывод.

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

Например, int = 1000 можно преобразовать в строку 1.001. Это может привести к тому, что операции сравнения вообще не будут работать.

Поэтому я настоятельно рекомендую использовать std::to_string. Это проще и делает то, что вы ожидаете.

    
8
2017-08-18 12: 59: 46Z
  1. Я согласен, что это серьезная проблема, если вам нужно обмениваться данными. К сожалению, std::to_string также использует текущую локаль (см. en.cppreference.com/w/cpp /string /basic_string /to_string , раздел «Примечания»). Почти все стандартные инструменты (от строковых потоков до sprintf, но также и sscanf и т. Д.) Используют текущую локаль. Я не знал об этом до недавнего времени, когда это сильно ударило меня. В настоящее время используются домашние вещи, которые не сложно сделать.
    2017-10-24 22: 05: 46Z
  2. В приведенной выше ссылке также указано, что C ++ 17 предоставляет std :: to_chars в качестве высокопроизводительной альтернативы, не зависящей от локали.
    2018-01-10 12: 01: 40Z
  3. К сожалению, я застрял в C ++ 11 на предстоящий год (а), к счастью, уже довольно неплохо).
    2018-01-12 21: 39: 51Z

Довольно просто добавить синтаксический сахар, который позволяет составлять строки на лету потоковым способом

 
#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;
}
    
3
2018-02-03 09: 17: 31Z

Использование:

 
#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}
    
2
2017-12-16 22: 07: 11Z
  1. Работает только с литеральными числами, не оценивает содержимое переменной, хотя иногда полезно.
    2016-05-31 12: 48: 26Z
  2. Верно. Но определенно удобно во время
    2016-10-03 04: 26: 08Z
  3. Работает только во время компиляции с литеральными числами констант, я думаю, что OP запрашивает динамическое преобразование, используя переменные целые числа
    2017-11-03 01: 48: 49Z

C ++ 17 предоставляет std :: to_chars в качестве высшего альтернатива, не зависящая от локали.

    
2
2019-01-04 11: 21: 05Z
 
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).

    
1
2019-05-31 12: 03: 56Z
  1. Хотя это решение работает, его крайне не рекомендуется! Имена, начинающиеся с подчеркивания и заглавной буквы, зарезервированы для компилятора, вы никогда не должны их использовать. Внедрение функций в пространство имен std - это тоже не то, что вы должны делать. Кроме того, не похоже, что _MAX_INT_DIG является стандартным макросом, поэтому, если он определен неправильно, этот код обладает большим потенциалом вызывать неопределенное поведение. -1
    2014-11-19 14: 57: 57Z
  2. Что такое _MAX_INT_DIG и почему оно удвоено?
    2015-03-25 16: 27: 14Z

Я использую:

 
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.

    
1
2019-05-31 12: 07: 09Z
 
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;
}
    
1
2019-05-31 12: 11: 49Z
  

Вот еще один простой способ сделать

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

sprintf - широко известный способ вставки любых данных в строку необходимого формата.

Вы можете преобразовать массив char * в строку, как показано в третьей строке.

    
1
2019-05-31 12: 16: 12Z

Использование:

 
#include "stdafx.h"
#include<iostream>
#include<string>
#include<string.h>

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;
}
    
1
2019-05-31 12: 17: 36Z

Это сработало для меня -

Мой код:

 
#include <iostream>
using namespace std;

int main()
{
    int n = 32;
    string s = to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}
    
1
2019-05-31 12: 21: 22Z
  1. По существу, что? stringstream?
    2019-05-31 12: 22: 12Z

Я думаю, что использовать 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;
 }
    
0
2019-05-31 12: 19: 37Z

Использование "чистого" C ++ (без C ++ 11 и т. д.):

 
#include <bits/stdc++.h>

using namespace std;

string to_str(int x) {
    ostringstream ss;
    ss << x;
    return ss.str();
}

int main()
{
    int number = 10;
    string s = to_str(number);
    cout << s << endl;
    return 0;
}
    
0
2019-05-31 18: 01: 23Z
  1. Почему это чисто?
    2019-06-22 13: 34: 44Z
  2. Это просто "чистый" в кавычках, хорошо? Я имею в виду, что не нужно никакой специальной библиотеки или версии C ++. Он работает в любой стандартной установке C ++.
    2019-06-22 14: 21: 36Z

Если вам нужно быстрое преобразование целого числа с фиксированным числом цифр в char *, дополненное слева символом «0», это удобный пример:

 
int n = 27;
char s[8];

Если вы конвертируете двузначное число:

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

И так далее до семизначных чисел:)

    
- 1
2017-03-29 22: 02: 51Z
  1. А как насчет порядка следования байтов?
    2019-01-10 15: 31: 54Z
 
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);
    
- 1
2019-05-31 12: 03: 39Z
  1. утечка памяти, -1 у меня
    2015-03-25 16: 27: 41Z

Вы можете просто сделать:

 
int a = 10;
string str = a + '0';
    
- 1
2019-05-31 12: 20: 26Z
  1. Уточните свой код.
    2019-04-08 13: 50: 02Z

Если вы используете MFC , вы можете использовать CString:

 
int a = 10;
CString strA;
strA.Format("%d", a);
    
- 1
2019-06-25 18: 13: 54Z
  1. Следует отметить, что это расширение только для Microsoft: msdn.microsoft.com/en-us/library/ms174288.aspx
    2014-02-05 16: 57: 02Z
  2. Мне нравится идея CString :: Format (). К сожалению, это не только переносимая MS.
    2016-02-24 13: 46: 19Z
  3. Я обновил свой ответ, включив в него информацию из вашего комментария @JonnyJD, поскольку я продолжаю опускаться за него 5 лет спустя.
    2019-06-25 18: 14: 45Z
 
int n = 123;
std::string str = std::to_string(n);
    
- 2
2018-07-26 14: 20: 42Z
  1. Привет! Не могли бы вы добавить объяснение, почему и как это дает ответ на вопрос?
    2018-07-26 14: 21: 23Z

Вы используете тип счетчика алгоритма для преобразования в строку. Я получил эту технику от программирования компьютеров Commodore 64 . Это также хорошо для программирования игр.

  • Вы берете целое число и берете каждую цифру, которая взвешена на степени 10. Поэтому предположим, что целое число равно 950.

    • Если целое число равно или больше 100 000, то вычтите 100 000 и увеличьте счетчик в строке на ["000000"];
      продолжайте делать это, пока не останется больше цифр в позиции 100 000. Отбрось еще одну степень десяти.

    • Если целое число равно или больше 10000, то вычтите 10000 и увеличьте счетчик в строке на ["000000"] + 1 позиция;
      продолжайте делать это до тех пор, пока в позиции 10 000 больше не останется цифр.

  • Отбрось еще одну степень десяти

  • Повторите шаблон

Я знаю, что 950 слишком мал для использования в качестве примера, но я надеюсь, что вы поняли идею.

    
- 3
2019-05-31 12: 13: 39Z
источник размещен Вот