Самый простой способ конвертировать int в string в C++
25 ответов
в 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);
Примечание:[строка.преобразования] (21.5 на n3242)
взяв в руки дискуссии с @В. 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 ) );
оригинальный ответ:
так как " преобразование ... to string " является повторяющейся проблемой, я всегда определяю 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++, но содержит много полезных расширений библиотеки.
на
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 микросекунды (на моем машина), а затем значительно ускоряется после этого, если сделано избыточно, но не столько, сколько предыдущие функции.
конечно есть и другие варианты, и вы даже можете обернуть это в свою собственную функцию, но это аналитический взгляд на некоторые из популярных из них.
использование:
#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++.
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 * в строку, как показано в третьей строке.
Я думаю, что использовать 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 слишком мало использовать как пример, но надеюсь вы поняли.