Что такое код itoa


char *itoa(int num, char *str, int radix)

Эта функция не определена стандартом ANSI С.

Функция itoa() конвертирует целое число num в строчный эквивалент и помещает результат в строку, на которую указывает параметр str. Основание системы счисления для записи выходной строки определено параметром radix, который может принимать значения в интервале от 2 до 36.

Функция itoa() возвращает указатель на str. Функция не имеет возвращаемого значения, соот­ветствующего ошибке. Необходимо заботиться о том, чтобы строка для вывода данных была до­статочно длинной, чтобы вместить в себя результат. Максимальная необходимая длина составляет 17 байт.

Itoa варианты

The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _itoa. See online help for details.

Converts an integer to a string. More secure versions of these functions are available; see _itoa_s, _i64toa_s, **********, _itow_s, _i64tow_s, **********. char *_itoa( int value, char *str, int radix ); char *_i64toa( __int64 value, char *str, int radix ); char * ********( unsigned _int64 value, char *str, int radix ); wchar_t * _itow( int value, wchar_t *str, int radix ); wchar_t * _i64tow( __int64 value, wchar_t *str, int radix ); wchar_t * ********( unsigned __int64 value, wchar_t *str, int radix ); template char *_itoa( int value, char (&str)[size], int radix ); // C++ only template char *_i64toa( __int64 value, char (&str)[size], int radix ); // C++ only template char * ********( unsigned _int64 value, char (&str)[size], int radix ); // C++ only template wchar_t * _itow( int value, wchar_t (&str)[size], int radix ); // C++ only template wchar_t * _i64tow( __int64 value, wchar_t (&str)[size], int radix ); // C++ only template wchar_t * ********( unsigned __int64 value, wchar_t (&str)[size], int radix ); // C++ onlyParameters value Number to be converted. str String result. radix Base of value; which must be in the range 2–36. Return Value Each of these functions returns a pointer to str. There is no error return.

из текста я понял что есть новый синтаксис itoa.

Где функция itoa в Linux?

itoa() — действительно удобная функция для преобразования числа в строку. Linux, похоже, не имеет itoa() , есть ли эквивалентная функция или мне нужно использовать sprintf(str, «%d», num) ?

EDIT: Извините, я должен был помнить, что эта машина явно нестандартна, подключив различные нестандартные реализации libc для академических целей; -)

Поскольку itoa() действительно нестандартен, как упоминалось несколькими полезными комментаторами, лучше использовать sprintf(target_string,»%d»,source_int) или (еще лучше, потому что он безопасен от переполнения буфера) snprintf(target_string, size_of_target_string_in_bytes, «%d», source_int) . Я знаю, что это не совсем лаконично или круто, как itoa() , но по крайней мере вы можете писать один раз, запускать везде ™; -)

Здесь старый (отредактированный) ответ

Вы правы, указав, что по умолчанию gcc libc не включает itoa() , как и несколько других платформ, из-за которого технически не является частью стандарта. См. здесь для получения дополнительной информации. Обратите внимание, что вы должны

Конечно, вы уже это знаете, потому что вы хотели использовать itoa() в Linux после предположительного использования его на другой платформе, но. код (украденный из ссылки выше) будет выглядеть так:

Описание функций C (Си) / C++ — itoa

Описание функций C (Си) / C++ — itoa

#include Требуется только для
объявления функции
char *itoa(value,string,radix);
int value; преобразуемое число
char *string; строка результата
int radix; основание value

Функция itoa преобразует символы числа value в символьную
строку, заканчивающуюся NULL-символом, и запоминает результат в
string. Аргумент radix определяет основание системы счисления для
value; его значение может лежать в пределах от 2 до 36. Если
radix = 10 и value — отрицательное число, то первым символом в
строке результата будет знак минус.

Функция itoa возвращает указатель на строку. Возвращаемого
значения в случае ошибки нет.
См.также ltoa, ultoa.

Замечание! Размер памяти, отводимой для string, должен быть
больше, чем требуется для возвращаемой строки. Функция может воз-
вращать строку длиной до 17 байтов.

#include
int radix=8;
char buffer[20];
char *p;
p=itoa(-3445,buffer,radix); /*p=»1712113″*/

Что такое код itoa

Здравствуйте уважаемые.
Копался в IAR 5.50 функций itoa(), Ltoa(), вот эти варианты проверил, работают.
Может кому нибудь интересно.

void ltoa(long int n,char *str)
<
unsigned long i;
unsigned char j,p;
i=1000000000L;
p=0;
if (n void reverse(char s[])
<
int i, j;
char c;
for (i = 0, j = strlen(s)-1; i void itoa(int n, char s[])
<
int i, sign;
if ((sign = n) 0); // удаляем
if (sign

Где функция itoa в Linux?

itoa() Это очень удобная функция для преобразования числа в строку. Linux не кажется itoa() , есть ли эквивалентная функция или я должен использовать sprintf(str, «%d», num) ?

16 ответов

EDIT: Извините, я должен был помнить, что эта машина решительно нестандартна, подключив различные нестандартные libc реализации в академических целях ; -)


As itoa() действительно нестандартно, как упоминалось несколькими полезными комментаторами, лучше всего использовать sprintf(target_string,»%d»,source_int) или (что еще лучше, потому что это безопасно от переполнения буфера) snprintf(target_string, size_of_target_string_in_bytes, «%d», source_int) . Я знаю, что это не совсем так лаконично или круто, как itoa() , но, по крайней мере, вы можете написать один раз, запустить везде ™ ;-)

вот старый (отредактированный) ответ

вы правы в том, что по умолчанию gcc libc не входит itoa() , как и несколько других платформ, из-за того, что он технически не является частью стандарта. См.здесь немного подробнее. Обратите внимание, что вы должны

конечно, вы уже знаете это, потому что вы хотели использовать itoa() на Linux после предположительно использования его на другой платформе, но. этот код (украденный из ссылки выше) будет выглядеть так:

пример

выход:

надеюсь, что это помогает!

Если вы называете это много, совет «просто использовать snprintf» может быть раздражающим. Итак, вот что вы, вероятно, хотите:

Илон Маск рекомендует:  Операторы и приоритеты

Edit: Я только что узнал о std::to_string который идентичен в работе моей собственной функции ниже. Он был представлен в C++11 и доступен в последних версиях gcc, по крайней мере, уже в 4.5, если вы включите расширения C++0x.

Не только itoa отсутствует в gcc, это не самая удобная функция для использования, так как вам нужно кормить его буфером. Мне нужно было что-то, что можно было бы использовать в выражении, поэтому я придумал этот:

обычно было бы безопаснее использовать snprintf вместо sprintf но буфер тщательно определен размер для того чтобы быть невосприимчив к переполнению.

Как писал Мэтт Джей, есть itoa , но это не стандарт. Ваш код будет более портативным, если вы используете snprintf .

itoa не является стандартной функцией C. Вы можете реализовать свой собственный. Он появился в первом издании Керниган и Ричи Язык Программирования C на стр. 60. Второе издание языка программирования C («K&R2») содержит следующую реализацию itoa на стр. 64. В книге отмечается несколько вопросов с этой реализацией, в том числе тот факт, что он неправильно обрабатывает большинство отрицательное число

функции reverse использованный выше реализован двумя страницами ранее:

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

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

N. B. поскольку snprintf копирует n-1 байт, мы должны вызвать snprintf (buf, len+1, «%ld», n) (не только snprintf (buf, len, «%ld», n))

вот намного улучшенная версия решения Archana. Он работает для любого radix 1-16 и numbers

в Linux нет такой функции. Вместо этого я использую этот код.

прямая копия в буфер: 64-битное целое число itoa hex:

Примечание: изменение долго долго долго для 32-битной машины. long to int в случае 32-битного целого числа. м-это радикс. При уменьшении радиуса увеличьте количество символов (переменная i). При увеличении радиуса уменьшите количество символов (лучше). В случае неподписанного типа данных я просто становлюсь 16 + 1.

я попробовал свою собственную реализацию itoa (), похоже, работает в двоичном, восьмеричном, десятичном и шестнадцатеричном

Как правильно объявлять itoa в Visual studio 2012?

При запуске приложения вылетает ошибка:

The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _itoa. см. объявление «itoa».

Как правильно объявлять itoa ? Библиотека подключена.

4 ответа 4

Доброго времени суток! Я так понимаю используется MS Visual Studio. Если так, то на мой взгляд у Вас есть 2 пути:

первый — снизить уровень жесткости проверки синтаксиса и используемых функций, что не рекомендуется;


второй — использовать более безопасные по мнению Microsoft функции: (_itoa_s, _i64toa_s, _ui64toa_s, _itow_s, и проч.)

_itoa не нужно объявлять, она уже объявлена в

Просто подключить и использовать.

Лучше itoa не использовать вообще, делать лучше так:

include … sstream ss; ss число которое нужно сконвертить переменная = ss.str();

Прошу не пинать за возможные ошибки, т.к. писал по помяти.

Я не знаю как добавлять коменты. Во первых, аргумент itoa не всегда int, а это неявное преобразование со всеми вытекающими (скорость, точность). Во-вторых второй аргумент itoa – буфер неизвестной длины. Если задать очень большую длину – будет перерасход памяти, а если сильно маленький – результат может не поместиться. И где простота ?

Преобразуем в строку. Часть 1. Целые числа.

1. sprintf

Первое что приходит в голову это функция sprintf из стандартной библиотеки Си. Использовать её просто:

После чего в массиве buffer у нас лежит требуемая строка.
Но вот беда, sprintf это ведь функция форматированного вывода, которая много чего умеет и тянет за собой много другие функций стандартной библиотеки. Размер машинного кода при ее использовании увеличивается значительно. Например, даже минимальная версия sprintf из avr-libc (это то, что идет в составе WinAVR / AVR Toolchain) добавляет чуть менее 2 килобайт.

2. utoa, ultoa

В состав библиотек, поставляемых с компиляторами, часто включают функции преобразования числа в строку itoa, ltoa, utoa, ultoa. Вообще эти функции не стандартные, ног часто имеются в наличии и, в отличии от sprintf, не делают ничего лишнего.

3. Извлечение цифр делением на 10.

Готовые стандартные и не очень способы посмотрели. Теперь пришло время свои велосипеды изобретать. Первый самый очевидный способ это конечно деление на 10 и вычисление остатка в цикле.

Остаток от деления выдаёт нам десятичные цифры в обратном порядке, начиная с младшего, поэтому записываем из в буфер начиная с конца, чтоб потом не разворачивать полученную строку.
Всё вроде просто красиво, ничего лишнего, но есть одно но. Собственно деление, да еще и вычисление остатка. Если в процессоре нет аппаратного деления, то это очень медленно.

4. Извлечение цифр делением на 10 с помощью функции div

Может попробовать использовать стандартную функцию div, которая возвращает сразу частное и остаток?

Но деление всё равно остается. К преимуществам этого и предыдущего метода можно отнести то, что они могут преобразовывать число в строку по любому основанию (если ёх чуть доработать), не обязательно 10.

5. Деление на 10 сдвигами и сложениями.

Если у целевого процессора нет аппаратной поддержки 32-х разрядного деления, то предыдущие два метода будут довольно медленными. Деление на 10 можно заменить на серию сдвигов и сложений. Вдохновившись книжкой «Алгоритмические трюки для программистов» (она-же «Hacker’s delight»), берём оттуда функцию деления на 10 с помощью сдвигов и сложений, заменив имеющееся там умножение на 10 (оно тоже «дорогое», на AVR по крайней мере) также сдвигами и сложениями. Модифицируем ее, чтоб она возвращала и частное и остаток:

Выглядит страшно и непонятно, но на самом деле всё просто. Сначала умножаем исходное число на 0.8 или 0.1100 1100 1100 1100 1100 1100 1100 1100 в двоичном представлении. Очень удобно, что дробь периодическая и удалось обойтись всего пятью сдвигами и четырьмя сложениями. Далее делим то, что получилось на 8, сдвигая на 3 разряда вправо. Получается исходное число делённое на 10 с точностью до единицы из-за ошибок округления. После находим остаток умножая полученное частное на 10 и вычитая его из исходного числа. Если остаток больше 9, то корректируем его и частное.
Сама функция использующее «быстрое» деление не отличается по виду от своих предшественниц.

6. Вычитание степеней 10.

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

40 байт размером. И сама функция:

Работает очень просто, пока число больше текущей степени 10 вычитаем эту степень 10 из числа и считаем сколько раз вычлось. Потом переходим на меньшую степень 10. И так пока не доберёмся до 1. Цифры получаются сразу в нужном порядке, нужно только удалить ведущие нули.

Илон Маск рекомендует:  Функции xslt

Методы на двоично-десятичных числах.

Следующие три метода основаны на операциях с упакованными двоично-десятичными числами — binary coded decimals (BCD). В этом представлении каждая тетрада (4 бита) хранит одну десятичную цифру. В 32-х разрядной переменной можно таким образом хранить 8 десятичных цифр. В двоичном представлении в 2-х разрядной переменной 10 десятичных цифр. Поэтому эти методы дают урезанные результаты для чисел больше 99999999. Двоично-десятичные числа очень легко преобразуются в строку:


Собственно из операций с BCD нам нужно сложение и умножение на 2, которое успешно заменяется сложением числа с самим собой. Поэтому нужно только сложение:

Выглядит страшно и непонятно — опять какое-то хитрое побитовое колдунство. На самом деле, чтоб сложить два BCD нужно просто сложить их как обычные двоичные числа — строчка a += b. А потом к каждой тетраде значение которой оказалось больше 9 нужно добавить корректирующее число 6 с переносом бита в старшую тетраду. И к каждой тетраде из которой был перенос бита в старшую тетраду, нужно также добавить корректирующее число 6. Все остальные строки функции — как раз эта коррекция. В первых двух строках мы определяем все биты суммы a + b + 0x66666666ul, которые изменили своё значение из-за переноса бита из младшего разряда. В третей строка складываем наши два числа. В четвёртой — выделяем младшие биты переноса для каждой тетрады. В остальных — прибавляем 6 к тем тетрадам из которых был перенос бита. Вот так вот — без единого условного перехода.

7. Сложение степеней двойки.

Первый способ, хорошо всем знакомый еще со школьных уроков информатики, — сложение десятичных представлений степеней двойки, соответствующих единичным битам в преобразуемом числе:

7. Сложение степеней двойки с таблицей.

В предыдущем методе используется два сложения двоично-десятичных чисел. От одного из них можно избавиться беря степень двойки из таблицы:

Таблица содержит 30 элментов — 120 байт.

8. Horner’s method

В этом методе на каждом шаге удваиваем накопленный десятичный результат, если старший бит двоичного числа единица, то добавляем к результату единицу, двоичное число при этом умножаем на 2 (сдвигаем на бит влево).

Здесь уже две операции сложения BCD, но одна из них сложение с 1 и от неё одной можно избавиться.

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

9. Извлечение цифр умножением на 10.

Идея заключается в том, что десятичные цифры можно извлекать со стороны старших бит числа и использовать умножение на 10 для перехода к следующему десятичному разряду. Для этого придётся представить наше двоично число как дробную часть, мысленно перенести запятую на сколько-то разрядов влево, в нашем случае это будет 27. При этом число будет состоять из 2^-27 долей. Чтоб извлекать десятичные цифры эта дробь должна состоять из каких-то десятичных долей пусть это будет 10^-9. Его нужно для этого умножить на 2^-27/10^-9 = 1.34217728. После этого биты начиная с 27 разряда будут содержать старшую десятичную цифру. Но это если исходное число было меньше 2^27. Если оно было больше, то две цифры со значением не более 31. Это надо учесть. Еще один момент — это переполнение. Начиная с чисела 3199999999 ((2^32-1) / 1.34217728) у нас будет переполнение на 1 разряд, которое тоже надо учесть. А как-же всё-таки умножить челое число на 1.34217728 и без изпользования плавающей точки? Всё так-же сдвиками и сложениями. И так вот, что получилось:

Как ни странно но это работает. Если кто-нибудь видел этот способ раньше — скажите мне, а то я могу претендовать на авторство.
Как видно при умножении пришлось использовать 40-ка битную арифметику — дополнительный байт для дробной части. Если дробную часть отбросить и использовать 32-х битную арифметику, то возникают ошибки округления, который достигают 7 для больших чисел. К сожалению в языке Си нет доступа к биту переноса и по этому перенос в/из дробной части пришлось организовывать вручную. Для эффективного использования бита переноса можно использовать ассемблерные вставки. Поскольку первая тестируемая платформа у нас будет avr-gcc, для него их и напишем, чисто ради спортивного интереса. С ними цикл умножения будет выглядеть так:

Бенчмарк

Теперь собственно та часть ради которой всё затевалось — сравнение скорости работы. Первой испытанной платформой будет будет AVR с использованием компилятора GCC.
Для методов разных типов время работы будет зависеть от разных факторов, например для методов основанных на делении на 10 время будет зависеть в большей степени от количества десятичных цифр, о есть от абсолютной величины числа и очень мало от самих этих цифр. Вычитание степеней 10 в цикле будет тем быстрее работать чем меньше сумма десятичных цифр составляющих число. То есть 1000000 обработается гораздо быстрее чем 999999. Методы основанные на двоично-десятичных числах будут быстрее работать если в исходном числе мало единичных бит — быстрее всего со степенями двойки. Время работы последнего метода будет зависеть только от абсолютной величины преобразуемого числа, но в меньшей степени чем методы с делением на 10. Итак в наборе для тестирования должны быть маленькие чила, большие числа, степени двойки, степени десяти, числа где много девяток.
Всякие тесты для AVR удобно проводить на симуляторе Simulavr — не нужно никакого железа, и многочисленных перепрошивок.
Для замера времени выполнения наших функций воспользуемся 16-ти разрядным таймером, тикающем на частоте ядра. Вывод на консоль через отладочный порт эмулятора. Оптимизация кода максимальная по скорости.
Вот что получилось в результате для 32-х разрядных чисел:

* после плюса размер зависимостей — таблицы или функции деления
** в скобках указаны результаты для варианта с ассемблерными вставками.

Лидирует в этом бенчмарке с не большим отрывом метод на быстром делении на 10 сдвигами и сложениями. К нему близко подобралось вычитание степеней 10. Следом метод с умножением на 10. методы с честным делением (включая utoa), как и ожидалось, самые медленные, особенно тот, что использует функцию ldiv, но и самые компактные. Время выполнения метода Хорнера практически не зависит от конвертируемого числа. sprintf работает относительно быстро, по сравнению с utoa. И не удивительно — у неё внутри используется метод похожий на utoa_fast_div, но накладные на разбор форматной строки и медленный вывод в буффер через fputc дают о себе знать.

Илон Маск рекомендует:  Подгрузка меню для сайта с фреймами

UPDATE.
Результат для 16-х разрядных чисел:

Здесь опять с заметным преимуществом лидирует быстрое деление сдвигами/сложениями. Худший результат теперь у sprintf, ведь внутри она всё равно использует 32- разрядные числа.

UPDATE #2. Результаты для MSP430.

Результат для 16-х разрядных чисел:

Поскольку кроме MSP430 Launcpad-а с камнем MSP430G2231 других MSP430 у меня нет, тестировать пришлось на нем. Все функции разумеется в него не помещаются, по этому заливаются и тестируются по одной с помощью скрипта.
Как видно честное деление здесь почти вдвое медленнее чем у AVR.
UPDETE #3

Результаты для STM32.

Обсуждение результатов

Аутсайдером везде является функция использующая библиотечную функцию деления div. Несмотря на то, что она возвращает за один вызов и остаток и частное от деления, даже на STM32 аппаратным делением, она реализована программно и работает очень медленно. Очевидно этот способ использовать не стоит. Однако функция использующая встроенный оператор деления utoa_builtin_div, плетущаяся в конце на AVR и MSP430, на STM32 — в лидерах. Ничего удивительного, ведь в Cortex M3 есть аппаратное деление скажут многие, и будут не совсем правы — деление-то там есть, но оно не такое уж и быстрое (в скобках для utoa_builtin_div указано время, если заставить компилятор сгенерировать честное деление). Дело в том, что хитрый GCC при делении на константу использует хитрый трюк — заменяет деление на умножение на константу такую, что старшие 32 бита в 64 разрядном произведении, содержат исходное делимое, делённое на 10.

Этот код эквивалентен примерно следующему:
uint32_t tmp = value;

Такой способ тоже описан в книжке «Алгоритмические трюки для программистов». Однако на AVR и MSP430 этот номер не пройдёт — там умножение 32*32 => 64 работает неприлично долго, дольше честного деления.
Еще utoa_builtin_div всегда имеет минимальный размер.
Всегда хороший, а зачастую лучший результат даёт деление на 10 сдвигами и сложениями utoa_fast_div. Это практически безусловный лидер по скорости и часто имеет вполне скромный размер. Этот метод всегда удачный выбор.
Любимое многими вычитание степеней десяти utoa_cycle_sub по размеру вместе с таблицей примерно совпадает сutoa_fast_div, но всегда немного уступает по скорости. Вобщем, тоже не плохой выбор.
Методы основанные на двоично десятичных числах работают не очень быстро, имеют не самый маленький размер и к тому-же выдают только 8 цифр результата (в моей реализации, можно получить все 10 цифр, но будет еще медленнее). Их лучше использовать не для преобразования двоичных чисел в строки, а для преобразования двоичных чисел в упакованные двоично десятичные, для последующей работы сними.
Особняком стоит метод с умножением на 10 utoa_fract. Он не выглядит очень привлекательным по среднему времени, однако его худшее время часто оказывается меньше, чем худшее время лидеров. У этого метода разница между лучшим и худшим относительно небольшая — он работает стабильно.

UPDATE.
Нашел еще один интересный и очень быстрый метод. Вот Вот здесь.


Описание того, как это работает по ссылке выше на английском. К сожалению, корректные результаты этот метод выдаёт только для 15-ти битных значений, зато очень быстро:
для AVR лучшее время — 133 такта, худшее — 167, среднее — 146.

Coming next.

Часть 2. Фиксированная и плавающая точка.

PS. Может быть кто знает еще какие нибудь методы преобразования чисел в строку?

Описание функций языка Си

All | _ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

atoi – преобразование строки в число типа int

#include
int atoi (const char *str);

str – указатель на строку, которую необходимо преобразовать в число.

Функция возвращает число — результат преобразование строки, если в начале строки содержится число. Если в начале строки стоит символ не являющейся цифрой, то функци возвращает ноль.

Функция atoi () преобразует строку, на которую указывает аргумент str, в число типа int. Преобразование заканчивается, когда встречается символ не являющейся цифрой или, когда будет преобразована вся строка. Если первый символ строки не цифра, то функция вернет 0 и завершит работу.

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

От функции atol () отличается типом возвращаемого числа и как следствие макимальной длинной преобразуемой строки. Для atoi возвращаемое число имеет тип int, а соответственно разрядность 16 или 32 бита в зависимости от аппаратной платформы, на которой запускается программа. Для atol возвращаемое число имеет тип long int, который всегда 32 разрядный, не зависимо от архитектуры процессора.

Так, на пример, в результате преобразования строки «217bg12» будет получено число 217, а при преобразовании строки «b237пр» будет получено число 0.

В примере преобразуется строка «652.23brrt» в число и результат выводится на консоль.

Что такое код itoa

Выполняю заказ по написанию программы под линуху, ну а так как сам в большенстве случаев пользуюсь виндой — пишу под визуал С++. На определённом этапе столкнулся с проблемой.. компилятор линухи не может нигде в библиотеках найти функцию itoa (перевод целочисленого типа в строковый). в хелпе вычитал что эта функция требует использования библиотеки: stdlib.h. Добавил, не помогло. Может кто-то знает как поступить? Или может знаете альтернативные функции?

з.ы. так как код работает под виндой, смысла приводить исходный код не вижу, а вот выдающую ошибку кину:

[root@bratislava second]# g++ -o lanko lankostud2.cpp -I’/usr/include/mysql’ -L’/usr/local/mysql/lib’ libmysqlclient.a -lz
lankostud2.cpp: In function `void sendresult(int, int, int)’:
lankostud2.cpp:285: `itoa’ undeclared (first use this function)
lankostud2.cpp:285: (Each undeclared identifier is reported only once for each
function it appears in.)

Рекомендовать в FAQ | Cообщить модератору | Наверх

Оглавление

  • C++, функция itoa , Soldier, 09:33 , 07-Мрт-04, (1)
    • C++, функция itoa , alexora, 11:17 , 07-Мрт-04, (2)

Индекс форумов | Темы | Пред. тема | След. тема
Сообщения по теме

>На определённом этапе столкнулся с проблемой.. компилятор линухи не может нигде
>в библиотеках найти функцию itoa (перевод целочисленого типа в строковый).

Уже раз двадцать здесь обсуждалось :))) Нету такой функции в Линукс. Можно реализовать на основе sprintf

1. «C++, функция itoa «
Сообщение от Soldier on 07-Мрт-04, 09:33 (MSK)
Рекомендовать в FAQ | Cообщить модератору | Наверх

2. «C++, функция itoa «
Сообщение от alexora on 07-Мрт-04, 11:17 (MSK)

>Уже раз двадцать здесь обсуждалось :))) Нету такой функции в Линукс. Можно реализовать на основе sprintf

int a = 911;
char* s = new char[32];
sprintf(s,»%i\0″,a);

Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL