Как работает atoi() на С++?

Ответ 1

Что-то вроде этого:

int atoi( const char *c ) {
    int value = 0;
    int sign = 1;
    if( *c == '+' || *c == '-' ) {
       if( *c == '-' ) sign = -1;
       c++;
    }
    while ( isdigit( *c ) ) {
        value *= 10;
        value += (int) (*c-'0');
        c++;
    }
    return value * sign;
}

Вы прокручиваете символы в строке до тех пор, пока они являются цифрами. Для каждого добавьте к счетчику, который вы храните - значение для добавления - это целочисленное значение символа. Это делается путем вычитания значения ascii '0' из значения ascii соответствующей цифры.

Обратите внимание, что этот код не обрабатывает переполнение. Если вы перейдете в "887452834572834928347578423485273" (который не поместится в int), результатом будет undefined.

Ответ 2

Цифры по цифре:

A char *, строго говоря, является указателем на a char. Указатель - это просто адрес в какое-то место в памяти. В C/С++ (и Java) строки состоят из символов, которые могут индивидуально рассматриваться как целые числа (обычно один байт), благодаря ASCII.

В C (и С++) указатель на элемент некоторого типа такой же, как указатель на массив элементов этого типа. Строки в чистом C - это просто массивы char s, с '\0' (NUL) в конце, чтобы вы знали, когда попадете в конец строки, не обойдя всю ее длину (указатель только адрес, он ничего не знает о том, на что он указывает).

Игнорировать ключевые слова const.

Версия C atoi выполняет цикл каждого символа в строке. *str++ делает несколько вещей (важно понять, как это работает, но это ужасный способ писать C). Это эквивалентно *(str++). str++ возвращает значение str (указатель), а затем увеличивает его на единицу (но возвращает старое значение!). * "разыгрывает" указатель, в основном читающий в char из памяти. Этот char хранится в digit, а затем сравнивается с NUL. Символы хранятся в ASCII, который представляет цифры смежно, поэтому мы можем просто проверить, что digit находится между 0 и 9. Мы знаем теперь, что мы читаем новую цифру, поэтому мы умножаем предыдущее значение на 10 на "сдвиг" "значение над, а затем добавить в цифру.

Версия Pure C:

int atoi(const char* str) {
  int num = 0;
  char digit;
  while ((digit = *str++) != '\0') {
    if (digit < '0' || digit > '9') {
      return num;  /* No valid conversion possible */
    }
    num *= 10;
    num += c - '0';
  }
  return num;
}

Строка С++ - это объект, облегчающий работу со строками. Вы можете получить char * из строки С++ с помощью .c_str().

Версия на С++ (скорее всего, встроенный вызов версии char * с "return atoi (str.c_str());" ):

int atoi(const std::string& str) {
  int n = 0;
  for (int i = 0; i < str.size(); i += 1) {
    char digit = str.at(i);   /* Could probably use iterator here,
                               * but this is more explicit. */
    if (digit < '0' || digit > '9') {
      return n;  /* No valid conversion possible. */
    }
    n *= 10;
    n += digit - '0';
  }
  return n;
}

Изменить: Исправлена ​​проблема, когда < > не отображалась должным образом.

Изменить: Добавлена ​​версия строки в С++

Изменить: Исправлено, так что он возвращает 123 в 123a случае.

Изменить: Изменено число без изменений в версии С++

Ответ 3

Поверните вопрос: как вы это делаете? Когда вы видите "31", как вы понимаете, сколько X нужно подсчитать, чтобы это равное?

    1 * the value in the leftmost column
+  10 * the value in the next column to the right
+ 100 * the value in the next column to the right
...

Ну, вы можете это исправить.

На самом деле это часто реализуется с самого правого персонажа для удобного использования с потоками. Как вы можете это сделать?

Ответ 4

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

Вот как я это сделал в С#. Та же общая идея.

Ответ 5

Мы используем atoi() для преобразования числовой строки в свое целочисленное значение. Это функция библиотеки c. Он принимает строку в качестве аргумента и возвращает целое значение.

В приведенном ниже примере я описываю метод для реализации собственной функции atoi.

#include<stdio.h>
#include<stdint.h>

/*Macro to check numeric character*/
#define Is_NUMERIC_STRING(d) (*(char*)d >= 48) && (*(char*)d<= 57)


uint32_t
StringToInt(const char *pszBuffer) {

uint32_t u32Number=0;

while( Is_NUMERIC_STRING(pszBuffer)) { //Loop terminate When alphabetic character occur.     

u32Number=(u32Number*10)+ (*pszBuffer-48);
pszBuffer++;
}

return u32Number;
}

int main() {
uint32_t d;

d=StringToInt("1230");

printf("%u\n",d);

return 0;
}

Для получения дополнительной информации вы можете увидеть эту ссылку: http://www.aticleworld.com/

Note: This code is only for the string whose value within the range of integer.

Ответ 6

В основном, вычитая ASCII-ноль ('0') и проверяя, является ли это цифрой или нет. Вам нужно знать позицию:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int atoi( const char* nptr )
{
    int result   = 0;
    int position = 1;

    const char* p = nptr;
    while( *p )
    {
        ++p;
    }
    for( --p; p >= nptr; p-- )
    {
        if( *p < 0x30 || *p > 0x39 )
        {
            break;
        }
        else
        {
            result += (position) * (*p - 0x30);
            position *= 10;
        }
    }
    result = ((nptr[0] == '-')? -result : result);
    return result;
}

int main()
{
    char buffer[BUFSIZ] = {0};

    printf( "Enter an integer: " );
    fgets( buffer, BUFSIZ, stdin );
    buffer[strlen(buffer)-1] = 0;

    printf( "You entered %d\n", atoi( buffer ) );

    return 0;
}

Ответ 7

Здесь реализована реализация, которая также проверяет условия ошибки и работает для любых целых типов.

#include <limits>
#include <string>
#include <cctype>
#include <cassert>
#include <type_traits>

template<typename TChar, typename TNumber> bool my_atoi(const std::basic_string<TChar>& str, TNumber& result)
{
    typedef std::make_unsigned<TNumber>::type TNumberUnsigned;

    // check if result type is integer
    assert(std::numeric_limits<TNumber>::is_integer);

    auto currChar = str.cbegin();

    // use corresponding unsigned type to accumulate number to avoid overflows for numbers such as -128
    TNumberUnsigned number = 0;

    bool isNegative = *currChar == '-';
    if (isNegative) {
        // negative numebers can only be parsed into signed types
        if (!std::numeric_limits<TNumber>::is_signed)
            return false;
        ++currChar;
    }

    // empty string or string containing just - sign are not valid integers
    if (currChar == str.cend())
        return false;

    while (currChar != str.cend()) {
        auto digit = *currChar - '0';

        // check that the next digit is valid
        if (digit < 0 || digit > 9)
            return false;

        // check for overflow
        if (number > std::numeric_limits<TNumberUnsigned>::max() / 10)
            return false;
        number *= 10;

        // check for overflow
        if (number > std::numeric_limits<TNumberUnsigned>::max() - digit)
            return false;
        number += digit;

        ++currChar;
    }

    if (isNegative) {
        // correctly check for negative overflow (-128)
        if (number > static_cast<TNumberUnsigned>(std::numeric_limits<TNumber>::max()) + 1)
            return false;

        result = static_cast<TNumber>(-1 * number);
    }
    else {
        if (number > static_cast<TNumberUnsigned>(std::numeric_limits<TNumber>::max()))
            return false;

        result = static_cast<TNumber>(number);
    }

    return true;
}