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

Самый простой способ конвертировать из 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();
1384
08 апр. '11 в 7:19
источник поделиться
28 ответов

С++ 11 вводит std::stoi (и варианты для каждого числового типа) и std::to_string, аналоги C atoi и itoa но выражается в std::to_string std::string.

#include <string> 

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

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

auto s = std::to_string(42);

Примечание: см. [String.conversions] (21.5 в n3242)

1833
08 апр. '11 в 9:13
источник

Связанные вопросы


Похожие вопросы

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

179
08 апр. '11 в 7:23
источник

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

#include <sstream>

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

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

102
30 нояб. '12 в 1:46
источник

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

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

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

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

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

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

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

85
08 апр. '11 в 7:23
источник

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

#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);
41
08 апр. '11 в 7:26
источник

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

#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
16 апр. '13 в 22:37
источник

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

string s = string(itoa(a));

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

19
08 апр. '11 в 7:22
источник

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

16
08 апр. '11 в 7:23
источник

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

#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
01 июня '13 в 0:32
источник

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

11
25 мая '14 в 16:42
источник

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

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

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

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

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

8
18 авг. '17 в 15:47
источник

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

boost/lexical_cast

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

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

Нет времени выполнения для отчета. У меня нет установленной 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
20 июня '17 в 17:48
источник

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

#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
03 февр. '18 в 12:17
источник

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

#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}
2
14 апр. '16 в 12:10
источник

С++ 17 предоставляет std :: to_chars в качестве высокопроизводительной независимой от локали альтернативы.

2
04 янв. '19 в 14:21
источник
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
21 февр. '13 в 13:18
источник
#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
05 июня '18 в 11:02
источник

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

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

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

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

1
07 февр. '18 в 19:10
источник
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
17 дек. '15 в 0:10
источник

У меня сработало вот этот код:

#include <iostream>
using namespace std;

int main()
{
    int n=32;
    string s=to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}
1
14 мая '19 в 14:12
источник

Я использую:

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 и linux g++.

1
18 янв. '14 в 22:59
источник

Я думаю, использование 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
17 сент. '18 в 16:37
источник
int n = 123;
std::string str = std::to_string(n);
-1
26 июля '18 в 16:46
источник

Почему ты не можешь просто сделать

int a = 10;
string str = a + '0';
-1
20 февр. '19 в 12:12
источник

Если вам требуется быстрое преобразование целого числа с фиксированным числом цифр в 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
25 нояб. '16 в 10:36
источник

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

int a = 10;
CString strA;
strA.Format("%d", a);
-1
05 февр. '14 в 19:25
источник
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs,"%d",timeStart.elapsed()/1000);
sprintf(bufMs,"%d",timeStart.elapsed()%1000);
-1
06 февр. '13 в 16:40
источник

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

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

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

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

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

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

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

-4
09 окт. '16 в 22:18
источник

Посмотрите другие вопросы по меткам или Задайте вопрос