C stoi обработка ошибки

This wrapper effectively removes some of the available functionality from std::stoi() because its signature is

int stoi(const std::string& str, std::size_t* pos = 0, int base = 10);

Because your wrapper does not allow a pos or base argument you cannot use it to give you the number of characters processed (with pos) nor to convert using a different base. std::stoi() provides default values for these arguments so you’d only have to provide them if you need the non-default behavior.

Also, you don’t take the std::string argument by const reference like std::stoi() — the string argument is probably not too expensive to copy in this context but why not accept the argument the same way std::stoi() does?

For completeness, I would also implement the overload of std::stoi() which accepts a std::wstring (and possibly std::stol() and std::stoll()).

I would also avoid the leading underscore, as identifiers with a leading underscore are reserved.

With these suggestions the wrapper would be implemented as

int stoi(const std::string& str, int* p_value, std::size_t* pos = 0, int base = 10) {
    // wrapping std::stoi because it may throw an exception

    try {
        *p_value = std::stoi(str, pos, base);
        return 0;
    }

    catch (const std::invalid_argument& ia) {
        //std::cerr << "Invalid argument: " << ia.what() << std::endl;
        return -1;
    }

    catch (const std::out_of_range& oor) {
        //std::cerr << "Out of Range error: " << oor.what() << std::endl;
        return -2;
    }

    catch (const std::exception& e)
    {
        //std::cerr << "Undefined error: " << e.what() << std::endl;
        return -3;
    }
}

I personally find that a regex is no overkill for this. Checking user input with a regex will have no negative impact on performance whatsoever.

But I think that you are more interested in exception handling. You need to read many many pages of a good C++ book to understand exception handling and its use cases.

And maybe, but I do not know, you want simply to catch the standard exceptions thrown by std::stoi. These are:

• std::invalid_argument
• std::out_of_range

That would be easy with writing

        // Standard exceptions for stoi
        catch (const std::invalid_argument & e) {
            std::cout << e.what() << "n";
        }
        catch (const std::out_of_range & e) {
            std::cout << e.what() << "n";
        }

But maybe you want to learn, how to write own exceptions. For your specific requirements. But please note that your specification, e.g. «more than 10 digits» and «no letter» are maybe not quite what you want. With a machine, where int is 32bit bit, the maximum number that can be converted is: 2147483647. Any number bigger and still having only 10 characters, will throw a std::out_of_range. On the other hand numbers like 123X would be converted by std::stoi to 123. So, maybe your requirements are not so clear.

Anyway, to show you, how you could use own exceptions, I create 2 customized exceptions classes. And to make life easy, I derived those from std::exception (recommended).

See the below example:

#include <iostream>
#include <string>
#include <algorithm>
#include <exception>
#include <cctype>
#include <vector>
#include <sstream>

class StoiException : public std::exception
{
public:
    StoiException(const std::string& msg) : message(msg) {}
    virtual const char* what() const noexcept override { return message.c_str(); }
protected:
    void setMessage(const std::string& msg) { message = msg; }
protected:
    std::string message{};
};

class NoNumber : StoiException
{
public:
    NoNumber(const std::string& msg) : StoiException(msg) { setMessage(std::string("My Exception -> NoNumber: ") + msg); }
    virtual const char* what() const noexcept override { return message.c_str(); }
};
class Overflow : StoiException
{
public:
    Overflow(const std::string& msg) : StoiException(msg) { setMessage(std::string("My Exception -> Overflow: ") + msg); }
    virtual const char* what() const noexcept override { return message.c_str(); }
};

int castInput(std::string& input) {
    int result{};
    // Check, if there is any letter in the input string
    if (std::any_of(input.begin(), input.end(), isalpha)) {
        // If so, than throw
        throw NoNumber(input);
    }
    // Check, if string has more than 10 characters
    if (input.length() > 10) {
        // If so, than throw
        throw Overflow(input);
    }
    result = std::stoi(input);
    return result;
}

std::istringstream testCin{ R"(123
   567
2147483647
2147483648
123X
12345678901
xyzxyzxyzxyzxyz
)" };


int main() {

    std::string input{};
    // Read all input
    while (testCin >> input) {
        try {
            // Convert
            int convert = castInput(input);
            // This will only be shown , if there is no exception
            std::cout << "nConverted Number is: " << convert << "n";
        }
        // Catch all exceptions
        catch (const NoNumber & e) {
            std::cout << e.what() << "n";
        }
        catch (const Overflow & e) {
            std::cout << e.what() << "n";
        }
        // Standard exceptions for stoi
        catch (const std::invalid_argument & e) {
            std::cout << e.what() << "n";
        }
        catch (const std::out_of_range & e) {
            std::cout << e.what() << "n";
        }
    }
    return 0;
}

Of course you can handle the std::stoi‘s exception also in your custom converter function. Then only your owwn exceptions are visible.

Please see:

#include <iostream>
#include <string>
#include <algorithm>
#include <exception>
#include <cctype>
#include <vector>
#include <sstream>

class StoiException : public std::exception
{
public:
    StoiException(const std::string& msg) : message(msg) {}
    virtual const char* what() const noexcept override { return message.c_str(); }
protected:
    void setMessage(const std::string& msg) { message = msg; }
protected:
    std::string message{};
};

class NoNumber : StoiException
{
public:
    NoNumber(const std::string& msg) : StoiException(msg) { setMessage(std::string("My Exception -> NoNumber: ") + msg); }
    virtual const char* what() const noexcept override { return message.c_str(); }
};
class Overflow : StoiException
{
public:
    Overflow(const std::string& msg) : StoiException(msg) { setMessage(std::string("My Exception -> Overflow: ") + msg); }
    virtual const char* what() const noexcept override { return message.c_str(); }
};

int castInput(std::string& input) {
    int result{};
    // Check, if there is any letter in the input string
    if (std::any_of(input.begin(), input.end(), isalpha)) {
        // If so, than throw
        throw NoNumber(input);
    }
    // Check, if string has more than 10 characters
    if (input.length() > 10) {
        // If so, than throw
        throw Overflow(input);
    }
    try {
        result = std::stoi(input);
    }
    // Standard exceptions for stoi
    catch (const std::invalid_argument & e) {
        throw NoNumber(input);
    }
    catch (const std::out_of_range & e) {
        throw Overflow(input);
    }
    return result;
}

std::istringstream testCin{ R"(123
   567
2147483647
2147483648
123X
12345678901
xyzxyzxyzxyzxyz
)" };


int main() {

    std::string input{};
    // Read all input
    while (testCin >> input) {
        try {
            // Convert
            int convert = castInput(input);
            // This will only be shown , if there is no exception
            std::cout << "nConverted Number is: " << convert << "n";
        }
        // Catch all exceptions
        catch (const NoNumber & e) {
            std::cout << e.what() << "n";
        }
        catch (const Overflow & e) {
            std::cout << e.what() << "n";
        }
    }
    return 0;
}

But maybe, what you really want to have, is a function, that encapsulates std::stoi and has an additional return value to show, if it worked or not.

Please note: The last solution will also convert «123X» to 123. That is the difference to the previous versions.

#include <iostream>
#include <string>
#include <algorithm>
#include <exception>
#include <cctype>
#include <vector>
#include <sstream>


std::pair<bool, int> castInput(std::string& input) {
    bool ok{ false };
    int result{};
    try {
        result = std::stoi(input);
        ok = true;
    }
    // Catch stoi errors
    catch (const std::invalid_argument & e) {}
    catch (const std::out_of_range & e) {}
    return {ok, result};
}

std::istringstream testCin{ R"(123
   567
2147483647
2147483648
123X
12345678901
xyzxyzxyzxyzxyz
)" };


int main() {
    std::string input{};
    // Read all input
    while (testCin >> input) {
            const auto [ok, convert] = castInput(input);
            if (ok)
                std::cout << "Converted value: " << convert << "n";
            else
                std::cout << "String '" << input << "' could not be convertedn";
    }
    return 0;
}

Interprets a signed integer value in the string str.

Discards any whitespace characters (as identified by calling std::isspace) until the first non-whitespace character is found, then takes as many characters as possible to form a valid base-n (where n=base) integer number representation and converts them to an integer value. The valid integer value consists of the following parts:

• (optional) plus or minus sign
• (optional) prefix (0) indicating octal base (applies only when the base is 8 or ​0​)
• (optional) prefix (0x or 0X) indicating hexadecimal base (applies only when the base is 16 or ​0​)
• a sequence of digits

The set of valid values for base is {0,2,3,...,36}. The set of valid digits for base-2 integers is {0,1}, for base-3 integers is {0,1,2}, and so on. For bases larger than 10, valid digits include alphabetic characters, starting from Aa for base-11 integer, to Zz for base-36 integer. The case of the characters is ignored.

Additional numeric formats may be accepted by the currently installed C locale.

If the value of base is ​0​, the numeric base is auto-detected: if the prefix is 0, the base is octal, if the prefix is 0x or 0X, the base is hexadecimal, otherwise the base is decimal.

If the minus sign was part of the input sequence, the numeric value calculated from the sequence of digits is negated as if by unary minus in the result type.

If pos is not a null pointer, then a pointer ptr — internal to the conversion functions — will receive the address of the first unconverted character in str.c_str(), and the index of that character will be calculated and stored in *pos, giving the number of characters that were processed by the conversion.

[edit] Parameters

[edit] Return value

Integer value corresponding to the content of str.

[edit] Exceptions

• std::invalid_argument if no conversion could be performed.
• std::out_of_range if the converted value would fall out of the range of the result type or if the underlying function (std::strtol or std::strtoll) sets errno to ERANGE.

[edit] Example

#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
 
int main()
{
    const auto data =
    {
        "45",
        "+45",
        " -45",
        "3.14159",
        "31337 with words",
        "words and 2",
        "12345678901",
    };
 
    for (const std::string s : data)
    {
        std::size_t pos{};
        try
        {
            std::cout << "std::stoi('" << s << "'): ";
            const int i{std::stoi(s, &pos)};
            std::cout << i << "; pos: " << pos << 'n';
        }
        catch (std::invalid_argument const& ex)
        {
            std::cout << "std::invalid_argument::what(): " << ex.what() << 'n';
        }
        catch (std::out_of_range const& ex)
        {
            std::cout << "std::out_of_range::what(): " << ex.what() << 'n';
            const long long ll{std::stoll(s, &pos)};
            std::cout << "std::stoll('" << s << "'): " << ll << "; pos: " << pos << 'n';
        }
    }
 
    std::cout << "nCalling with different radixes:n";
    for (const auto& [s, base] : { std::pair<const char*, int>
        {"11",  2}, {"22",  3}, {"33",  4}, {"77",  8},
        {"99", 10}, {"FF", 16}, {"jJ", 20}, {"Zz", 36}, })
    {
        const int i{std::stoi(s, nullptr, base)};
        std::cout << "std::stoi('" << s << "', " << base << "): " << i << 'n';
    }
}

std::stoi('45'): 45; pos: 2
std::stoi('+45'): 45; pos: 3
std::stoi(' -45'): -45; pos: 4
std::stoi('3.14159'): 3; pos: 1
std::stoi('31337 with words'): 31337; pos: 5
std::stoi('words and 2'): std::invalid_argument::what(): stoi
std::stoi('12345678901'): std::out_of_range::what(): stoi
std::stoll('12345678901'): 12345678901; pos: 11
 
Calling with different radixes:
std::stoi('11', 2): 3
std::stoi('22', 3): 8
std::stoi('33', 4): 15
std::stoi('77', 8): 63
std::stoi('99', 10): 99
std::stoi('FF', 16): 255
std::stoi('jJ', 20): 399
std::stoi('Zz', 36): 1295

[edit] See also