Самый простой способ преобразовать int в string в C++

взяв в руки дискуссии с @В. oddou пару лет спустя, в C++17, наконец, доставлены способ сделать изначально макрос-тип-агностик Решение (ниже) без проходя через макро уродство.

template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    ( 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 начинался как просто запись в stringstream, а затем извлечение обратно из потока, теперь у него есть пара из дополнений. Прежде всего, были добавлены специализации для довольно большого количества типов, поэтому для многих распространенных типов это существенно быстрее, чем использование stringstream. Во-вторых, теперь он проверяет результат, так что (например) если вы преобразуете из строки в int, он может вызвать исключение, если строка содержит что-то, что не может быть преобразовано в int (например, 1234 получится, но 123abc бросил бы).

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

int a = 20;
std::string s = 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);

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

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

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

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

можно использовать std::to_string доступно в C++11, как предложил Матье М.:

std::to_string(42);

или, если производительность имеет решающее значение (например, если вы делаете много конверсии), вы можете использовать fmt::FormatInt С Формат C++ библиотека для преобразования целого числа в std::string:

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

или строка C:

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

последний не делает никаких динамических выделений памяти и более чем в 10 раз быстрее, чем std::to_string на повышение кармы стандарты. Смотрите быстрое преобразование целого числа в строку в C++ для более подробной информации.

в отличие от std::to_string,fmt::FormatInt не требует C++11 и работает с любым компилятором c++.

отказ от ответственности: я являюсь автором библиотеки формата C++.

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

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

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

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

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

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

boost/lexical_cast

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

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

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

---

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

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

#define convertToString(x) #x

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

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

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

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)

Я использую:

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++.

используя CString:

int a = 10;
CString strA;
strA.Format("%d", a);

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

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

char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs,"%d",timeStart.elapsed()/1000);
sprintf(bufMs,"%d",timeStart.elapsed()%1000);

Если вам нужно быстро преобразовать целое число с фиксированным числом цифр в char * left-padded с '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;

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

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

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

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

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

int n = 123;
std::string str = std::to_string(n);

Я думаю, что использование 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, то вычитаем 10 000 и увеличим счетчик в строке на ["000000"] + 1 позицию;
    продолжайте делать это до тех пор, пока не будет больше чисел в позиции 10,000.

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

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

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