atoi: chars to signed

Functions
template<class T >
bool	c4::atoi (csubstr str, T *v) noexcept
	Convert a trimmed string to a signed integral value. More...
template<class T >
size_t	c4::atoi_first (csubstr str, T *v)
	Select the next range of characters in the string that can be parsed as a signed integral value, and convert it using atoi(). More...

Detailed Description

Function Documentation

template<class T >

bool c4::atoi ( csubstr  str, T *  v  )

inlinenoexcept

Convert a trimmed string to a signed integral value.

The input string can be formatted as decimal, binary (prefix 0b or 0B), octal (prefix 0o or 0O) or hexadecimal (prefix 0x or 0X). Strings with leading zeroes are considered as decimal and not octal (unlike the C/C++ convention). Every character in the input string is read for the conversion; the input string must not contain any leading or trailing whitespace.

Returns

true if the conversion was successful.

Note

a positive sign is not accepted. ie, the string must not start with '+'

overflow is not detected: the return status is true even if the conversion would return a value outside of the type's range, in which case the result will wrap around the type's range. This is similar to native behavior. See overflows: does a number string overflow a type and Check read for overflow for overflow checking utilities.

See also

atoi_first() if the string is not trimmed to the value to read.

Definition at line 1466 of file charconv.hpp.

Referenced by c4::atoi_first(), c4::atox(), c4::from_chars(), and parse_args().

{
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_STATIC_ASSERT(std::is_signed<T>::value);

    if C4_UNLIKELY(str.len == 0)
        return false;
    // no need for the assertion, but we leave it here to document
    // the expectation:
    //C4_ASSERT(str.str[0] != '+');

    T sign = 1;
    size_t start = 0;
    if(str.str[0] == '-')
    {
        if C4_UNLIKELY(str.len == ++start)
            return false;
        sign = -1;
    }

    bool parsed_ok = true;
    if(str.str[start] != '0') // this should be the common case, so put it first
    {
        parsed_ok = read_dec(str.sub(start), v);
    }
    else if(str.len > start + 1)
    {
        // starts with 0: is it 0x, 0o, 0b?
        const char pfx = str.str[start + 1];
        if(pfx == 'x' || pfx == 'X')
            parsed_ok = str.len > start + 2 && read_hex(str.sub(start + 2), v);
        else if(pfx == 'b' || pfx == 'B')
            parsed_ok = str.len > start + 2 && read_bin(str.sub(start + 2), v);
        else if(pfx == 'o' || pfx == 'O')
            parsed_ok = str.len > start + 2 && read_oct(str.sub(start + 2), v);
        else
            parsed_ok = read_dec(str.sub(start + 1), v);
    }
    else
    {
        parsed_ok = read_dec(str.sub(start), v);
    }
    if C4_LIKELY(parsed_ok)
        *v *= sign;
    return parsed_ok;
}

template<class T >

size_t c4::atoi_first ( csubstr  str, T *  v  )

inline

Select the next range of characters in the string that can be parsed as a signed integral value, and convert it using atoi().

Leading whitespace (space, newline, tabs) is skipped.

Returns

the number of characters read for conversion, or csubstr::npos if the conversion failed

See also

atoi() if the string is already trimmed to the value to read.

csubstr::first_int_span()

Definition at line 1521 of file charconv.hpp.

Referenced by c4::from_chars_first().

{
    csubstr trimmed = str.first_int_span();
    if(trimmed.len && atoi(trimmed, v))
        return static_cast<size_t>(trimmed.end() - str.begin());
    return csubstr::npos;
}