Преобразование L-строки в число

Для преобразования L-строки в число используются следующие функции:

  • _wtoi() — преобразует L-строку в число, имеющее тип int. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
int _wtoi(const wchar_t *str);

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

std::wcout << _wtoi(L"25") << std::endl;        // 25
std::wcout << _wtoi(L"2.5") << std::endl;       // 2
std::wcout << _wtoi(L"5str") << std::endl;      // 5
std::wcout << _wtoi(L"5s10") << std::endl;      // 5
std::wcout << _wtoi(L" \t\n 25") << std::endl;  // 25
std::wcout << _wtoi(L"-25") << std::endl;       // -25
std::wcout << _wtoi(L"str") << std::endl;       // 0

Если значение выходит за диапазон значений типа int, то в VC++ возвращается максимальное или минимальное значение типа int и переменной errno присваивается значение ERANGE:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << _wtoi(L"2147483649") << std::endl; // 2147483647
std::wcout << errno << std::endl;                // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}

В MinGW будет усечение значения:

std::wcout << _wtoi(L"2147483649") << std::endl; // -2147483647
std::wcout << errno << std::endl;                // 0
  • _wtol() — преобразует L-строку в число, имеющее тип long. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
long _wtol(const wchar_t *str);

Пример преобразования:

std::wcout << _wtol(L"25") << std::endl;       // 25
std::wcout << _wtol(L" \n -25") << std::endl;  // -25
std::wcout << _wtol(L"2.5") << std::endl;      // 2
std::wcout << _wtol(L"5str") << std::endl;     // 5
std::wcout << _wtol(L"5s10") << std::endl;     // 5
std::wcout << _wtol(L"str") << std::endl;      // 0

Если значение выходит за диапазон значений типа long, то в VC++ возвращается максимальное или минимальное значение типа long и переменной errno присваивается значение ERANGE:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << _wtol(L"2147483649") << std::endl; // 2147483647
std::wcout << errno << std::endl;                // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}

В MinGW будет усечение значения:

std::wcout << _wtol(L"2147483649") << std::endl; // -2147483647
std::wcout << errno << std::endl;                // 0
  • _wtoi64() — преобразует L-строку в число, имеющее тип __int64. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
__int64 _wtoi64(const wchar_t *str);

Пример преобразования:

std::wcout << _wtoi64(L"9223372036854775807") << std::endl;
// 9223372036854775807

Если значение выходит за диапазон значений типа __int64, то возвращается максимальное или минимальное значение типа __int64 и переменной errno присваивается значение ERANGE:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << _wtoi64(L"9223372036854775809") << std::endl;
// 9223372036854775807
std::wcout << errno << std::endl; // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}
  • wcstol() и wcstoul() — преобразуют L-строку в число, имеющее тип long и unsigned long соответственно. Прототипы функций:
#include <cwchar> /* или #include <wchar.h> */
long wcstol(const wchar_t *str, wchar_t **endPtr, int radix);
unsigned long wcstoul(const wchar_t *str, wchar_t **endPtr,
                      int radix);

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. В параметре radix можно указать систему счисления (число от 2 до 36). Если в параметре radix задано число 0, то система счисления определяется автоматически. Пример преобразования:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
wchar_t *p = nullptr;
std::wcout << std::wcstol(L"25", nullptr, 0)
           << std::endl;      // 25
std::wcout << std::wcstol(L"025", nullptr, 0)
           << std::endl;      // 21
std::wcout << std::wcstol(L"0x25", nullptr, 0)
           << std::endl;      // 37
std::wcout << std::wcstol(L"111", nullptr, 2)
           << std::endl;      // 7
std::wcout << std::wcstol(L"025", nullptr, 8)
           << std::endl;      // 21
std::wcout << std::wcstol(L"0x25", nullptr, 16)
           << std::endl;      // 37
std::wcout << std::wcstol(L"5s10", &p, 0)
           << std::endl;      // 5
std::wcout << p << std::endl; // s10

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то значение будет соответствовать минимальному (LONG_MIN или 0) или максимальному (LONG_MAX или ULONG_MAX) значению для типа, а переменной errno присваивается значение ERANGE. Пример:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << std::wcstol(L"str", nullptr, 0) << std::endl; // 0
std::wcout << std::wcstol(L"2147483649", nullptr, 0)
           << std::endl; // 2147483647 (соответствует LONG_MAX)
std::wcout << errno << std::endl; // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}
  • wcstoll() и wcstoull() — преобразуют L-строку в число, имеющее тип long long и unsigned long long соответственно. Прототипы функций:
#include <cwchar> /* или #include <wchar.h> */
long long wcstoll(const wchar_t *str, wchar_t **endPtr,
                  int radix);
unsigned long long wcstoull(const wchar_t *str ,wchar_t **endPtr,
                            int radix);

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. В параметре radix можно указать систему счисления (число от 2 до 36). Если в параметре radix задано число 0, то система счисления определяется автоматически. Пример преобразования:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
wchar_t *p = nullptr;
std::wcout << std::wcstoll(L"25", nullptr, 0)
           << std::endl;      // 25
std::wcout << std::wcstoll(L"025", nullptr, 0)
           << std::endl;      // 21
std::wcout << std::wcstoll(L"0x25", nullptr, 0)
           << std::endl;      // 37
std::wcout << std::wcstoll(L"111", nullptr, 2)
           << std::endl;      // 7
std::wcout << std::wcstoll(L"025", nullptr, 8)
           << std::endl;      // 21
std::wcout << std::wcstoll(L"0x25", nullptr, 16)
           << std::endl;      // 37
std::wcout << std::wcstoll(L"5s10", &p, 0)
           << std::endl;      // 5
std::wcout << p << std::endl; // s10

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то значение будет соответствовать минимальному (LLONG_MIN или 0) или максимальному (LLONG_MAX или ULLONG_MAX) значению для типа, а переменной errno присваивается значение ERANGE. Пример:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << std::wcstoll(L"str", nullptr, 0) << std::endl; // 0
std::wcout << std::wcstoll(L"9223372036854775809", nullptr, 0)
           << std::endl;
// 9223372036854775807 (соответствует LLONG_MAX)
std::wcout << errno << std::endl; // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}
  • _wcstoi64() и _wcstoui64() — преобразуют L-строку в число, имеющее тип __int64 и unsigned __int64 соответственно. Прототипы функций:
#include <cwchar> /* или #include <wchar.h> */
__int64 _wcstoi64(const wchar_t *str, wchar_t **endPtr,
                  int radix);
unsigned __int64 _wcstoui64(const wchar_t *str, wchar_t **endPtr,
                            int radix);

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. В параметре radix можно указать систему счисления (число от 2 до 36). Если в параметре radix задано число 0, то система счисления определяется автоматически. Пример преобразования:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
wchar_t *p = nullptr;
std::wcout << _wcstoi64(L"25", nullptr, 0) << std::endl;    // 25
std::wcout << _wcstoui64(L"25", nullptr, 0) << std::endl;   // 25
std::wcout << _wcstoi64(L"025", nullptr, 0) << std::endl;   // 21
std::wcout << _wcstoi64(L"0x25", nullptr, 0) << std::endl;  // 37
std::wcout << _wcstoi64(L"111", nullptr, 2) << std::endl;   // 7
std::wcout << _wcstoi64(L"025", nullptr, 8) << std::endl;   // 21
std::wcout << _wcstoi64(L"0x25", nullptr, 16) << std::endl; // 37
std::wcout << _wcstoi64(L"5s10", &p, 0) << std::endl;       // 5
std::wcout << p << std::endl; // s10

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то значение будет соответствовать минимальному или максимальному значению для типа, а переменной errno присваивается значение ERANGE. Пример:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << _wcstoi64(L"str", nullptr, 0) << std::endl; // 0
std::wcout << _wcstoi64(L"9223372036854775809", nullptr, 0)
           << std::endl; // 9223372036854775807
std::wcout << errno << std::endl; // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}
  • wcstoimax() и wcstoumax() — преобразуют L-строку в число, имеющее тип intmax_t и uintmax_t соответственно. Прототипы функций:
#include <inttypes.h>
intmax_t wcstoimax(const wchar_t *str, wchar_t **endPtr,
                   int radix);
typedef long long intmax_t;
uintmax_t wcstoumax(const wchar_t *str, wchar_t **endPtr,
                    int radix);
typedef unsigned long long uintmax_t;

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. В параметре radix можно указать систему счисления (число от 2 до 36). Если в параметре radix задано число 0, то система счисления определяется автоматически. Пример преобразования:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
wchar_t *p = nullptr;
std::wcout << wcstoumax(L"25", nullptr, 0) << std::endl;    // 25
std::wcout << wcstoimax(L"25", nullptr, 0) << std::endl;    // 25
std::wcout << wcstoimax(L"025", nullptr, 0) << std::endl;   // 21
std::wcout << wcstoimax(L"0x25", nullptr, 0) << std::endl;  // 37
std::wcout << wcstoimax(L"111", nullptr, 2) << std::endl;   // 7
std::wcout << wcstoimax(L"025", nullptr, 8) << std::endl;   // 21
std::wcout << wcstoimax(L"0x25", nullptr, 16) << std::endl; // 37
std::wcout << wcstoimax(L"5s10", &p, 0) << std::endl;       // 5
std::wcout << p << std::endl; // s10

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то значение будет соответствовать минимальному (INTMAX_MIN или 0) или максимальному (INTMAX_MAX или UINTMAX_MAX) значению для типа, а переменной errno присваивается значение ERANGE. Пример:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
// #include <stdint.h>
std::wcout << INTMAX_MIN << std::endl;  // -9223372036854775808
std::wcout << INTMAX_MAX << std::endl;  // 9223372036854775807
std::wcout << UINTMAX_MAX << std::endl; // 18446744073709551615
std::wcout << wcstoimax(L"str", nullptr, 0) << std::endl; // 0
std::wcout << wcstoimax(L"9223372036854775809", nullptr, 0)
           << std::endl;
// 9223372036854775807 (соответствует INTMAX_MAX)
std::wcout << errno << std::endl; // 34
if (errno == ERANGE) {
   std::wcout << L"Выход за диапазон значений" << std::endl;
}
  • _wtof() — преобразует L-строку в вещественное число, имеющее тип double. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
double _wtof(const wchar_t *str);

Пример преобразования (обратите внимание: от настроек локали зависит десятичный разделитель вещественных чисел):

_wsetlocale(LC_ALL, L"C");
std::wcout << _wtof(L"25") << std::endl;       // 25
std::wcout << _wtof(L"2.5") << std::endl;      // 2.5
std::wcout << _wtof(L"2,5") << std::endl;      // 2
std::wcout << _wtof(L"5.1str") << std::endl;   // 5.1
std::wcout << _wtof(L"5s10") << std::endl;     // 5
std::wcout << _wtof(L"str") << std::endl;      // 0
_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << _wtof(L"2.5") << std::endl;      // 2
std::wcout << _wtof(L"2,5") << std::endl;      // 2.5
  • wcstod() — преобразует L-строку в вещественное число, имеющее тип double. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
double wcstod(const wchar_t *str, wchar_t **endPtr);

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью вещественного числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. Пример преобразования (обратите внимание: от настроек локали зависит десятичный разделитель вещественных чисел):

_wsetlocale(LC_ALL, L"C");
wchar_t *p = nullptr;
std::wcout << std::wcstod(L" \t\n 25", nullptr)
           << std::endl;      // 25
std::wcout << std::wcstod(L"2.5", nullptr)
           << std::endl;      // 2.5
std::wcout << std::wcstod(L"2,5", nullptr)
           << std::endl;      // 2
std::wcout << std::wcstod(L"5.1str", nullptr)
           << std::endl;      // 5.1
std::wcout << std::wcstod(L"str", nullptr)
           << std::endl;      // 0
std::wcout << std::wcstod(L"14.5e5s10", &p)
           << std::endl;      // 1.45e+06
std::wcout << p << std::endl; // s10
_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << std::wcstod(L"2.5", nullptr) << std::endl; // 2
std::wcout << std::wcstod(L"2,5", nullptr) << std::endl; // 2.5

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то возвращается значение –HUGE_VAL или HUGE_VAL, а переменной errno присваивается значение ERANGE;

  • wcstof() — преобразует L-строку в вещественное число, имеющее тип float. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
float wcstof(const wchar_t *str, wchar_t **endPtr);

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью вещественного числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. Пример преобразования (обратите внимание: от настроек локали зависит десятичный разделитель вещественных чисел):

_wsetlocale(LC_ALL, L"C");
wchar_t *p = nullptr;
std::wcout << std::wcstof(L" \t\n 25", nullptr)
           << std::endl;      // 25
std::wcout << std::wcstof(L"2.5", nullptr)
           << std::endl;      // 2.5
std::wcout << std::wcstof(L"5.1str", nullptr)
           << std::endl;      // 5.1
std::wcout << std::wcstof(L"14.5e5s10", &p)
           << std::endl;      // 1.45e+06
std::wcout << p << std::endl; // s10
_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << std::wcstof(L"2.5", nullptr) << std::endl; // 2
std::wcout << std::wcstof(L"2,5", nullptr) << std::endl; // 2.5

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то возвращается значение –HUGE_VALF или HUGE_VALF, а переменной errno присваивается значение ERANGE;

  • wcstold() — преобразует L-строку в вещественное число, имеющее тип long double. Прототип функции:
#include <cwchar> /* или #include <wchar.h> */
long double wcstold(const wchar_t *str, wchar_t **endPtr);

Пробельные символы в начале строки игнорируются. Считывание символов заканчивается на символе не являющемся записью вещественного числа. Указатель на этот символ доступен через параметр endPtr, если он не равен NULL. Пример преобразования (обратите внимание: от настроек локали зависит десятичный разделитель вещественных чисел):

_wsetlocale(LC_ALL, L"C");
wchar_t *p = nullptr;
std::wcout << std::wcstold(L" \t\n 25", nullptr)
           << std::endl;      // 25
std::wcout << std::wcstold(L"2.5", nullptr)
           << std::endl;      // 2.5
std::wcout << std::wcstold(L"5.1str", nullptr)
           << std::endl;      // 5.1
std::wcout << std::wcstold(L"14.5e5s10", &p)
           << std::endl;      // 1.45e+06
std::wcout << p << std::endl; // s10
_wsetlocale(LC_ALL, L"Russian_Russia.1251");
std::wcout << std::wcstold(L"2.5", nullptr) << std::endl; // 2
std::wcout << std::wcstold(L"2,5", nullptr) << std::endl; // 2.5

Если в строке нет числа, то возвращается число 0. Если число выходит за диапазон значений для типа, то возвращается значение –HUGE_VALL или HUGE_VALL, а переменной errno присваивается значение ERANGE.

Для преобразования L-строки в число можно также воспользоваться функциями swscanf() и _snwscanf(). Прототипы функций:

#include <cwchar> /* или #include <wchar.h> */
int swscanf(const wchar_t *str, const wchar_t *format, ...);
int _snwscanf(const wchar_t *str, size_t maxCount,
              const wchar_t *format, ...);

В параметре str указывается L-строка, содержащая число, в параметре maxCount — максимальное количество просматриваемых символов в строке, а в параметре format — строка специального формата, внутри которой задаются спецификаторы, аналогичные применяемым в функции printf() (см. разд. 2.9), а также некоторые дополнительные спецификаторы. В последующих параметрах передаются адреса переменных. Функции возвращают количество произведенных присваиваний. Пример получения двух целых чисел:

_wsetlocale(LC_ALL, L"Russian_Russia.1251");
wchar_t str[] = L"20 30 str";
int n = 0, k = 0;
int count = std::swscanf(str, L"%d%d", &n, &k);
// int count = _snwscanf(str, std::wcslen(str), L"%d%d", &n, &k);
if (count == 2) {
   std::wcout << L"n = " << n << std::endl; // n = 20
   std::wcout << L"k = " << k << std::endl; // k = 30
}
else std::wcout << L"Не удалось преобразовать" << std::endl;

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

Учебник C++ (MinGW-W64)
Учебник C++ (MinGW-W64) в формате PDF

Помощь сайту

ЮMoney (Yandex-деньги): 410011140483022

ПАО Сбербанк:
Счет: 40817810855006152256
Реквизиты банка:
Наименование: СЕВЕРО-ЗАПАДНЫЙ БАНК ПАО СБЕРБАНК
Корреспондентский счет: 30101810500000000653
БИК: 044030653
КПП: 784243001
ОКПО: 09171401
ОКОНХ: 96130
Скриншот реквизитов