Ответ 1

Используйте boost:: lexical_cast. Если бросок не может быть выполнен, он выдает исключение.

#include <boost/lexical_cast.hpp>
#include <iostream>
#include <string>

int main(void)
{
    std::string s;
    std::cin >> s;

    try
    {
        int i = boost::lexical_cast<int>(s);

        /* ... */
    }
    catch(...)
    {
        /* ... */
    }
}

Без boost:

#include <iostream>
#include <sstream>
#include <string>

int main(void)
{
    std::string s;
    std::cin >> s;

    try
    {
        std::stringstream ss(s);

        int i;
        if ((ss >> i).fail() || !(ss >> std::ws).eof())
        {
            throw std::bad_cast();
        }

        /* ... */
    }
    catch(...)
    {
        /* ... */
    }
}

Повышение фальшивки:

#include <iostream>
#include <sstream>
#include <string>

template <typename T>
T lexical_cast(const std::string& s)
{
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof())
    {
        throw std::bad_cast();
    }

    return result;
}

int main(void)
{
    std::string s;
    std::cin >> s;

    try
    {
        int i = lexical_cast<int>(s);

        /* ... */
    }
    catch(...)
    {
        /* ... */
    }
}

Если вам нужны не-броские версии этих функций, вам придется поймать соответствующие исключения (я не думаю, что boost::lexical_cast предоставляет версию без броска), примерно так:

#include <iostream>
#include <sstream>
#include <string>

template <typename T>
T lexical_cast(const std::string& s)
{
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof())
    {
        throw std::bad_cast();
    }

    return result;
}

template <typename T>
bool lexical_cast(const std::string& s, T& t)
{
    try
    {
        // code-reuse! you could wrap
        // boost::lexical_cast up like
        // this as well
        t = lexical_cast<T>(s);

        return true;
    }
    catch (const std::bad_cast& e)
    {
        return false;
    }
}

int main(void)
{
    std::string s;
    std::cin >> s;

    int i;
    if (!lexical_cast(s, i))
    {
        std::cout << "Bad cast." << std::endl;
    }   
}

Ответ 2

Другой способ использования стандартных потоков:

#include <sstream>
#include <iostream>
#include <string>

int main()
{
    std::stringstream convertor;
    std::string numberString = "Not a number!";
    int number;

    convertor << numberString;
    convertor >> number;

    if(convertor.fail())
    {
        // numberString is not a number!
        std::cout << "Not a Number!";
    }
}

Ответ 3

Другие ответы, которые используют потоки, будут успешными, даже если строка содержит недопустимые символы после допустимого числа, например. "123abc". Я не знаком с повышением, поэтому не могу прокомментировать его поведение.

Если вы хотите знать, содержит ли строка число и только число, вы должны использовать strtol:

#include <iostream>
#include <string>

int main(void)
{
    std::string s;
    std::cin >> s;

    char *end;
    long i = strtol( s.c_str(), &end, 10 );
    if ( *end == '\0' )
    {
        // Success
    }
    else
    {
        // Failure
    }
}

strtol возвращает указатель на символ, который завершил синтаксический анализ, поэтому вы можете легко проверить, была ли проанализирована вся строка.

Обратите внимание, что strtol возвращает long, а не int, но в зависимости от вашего компилятора они, вероятно, одинаковы. В стандартной библиотеке нет strtoi-функции, только atoi, которая не возвращает символ окончания разбора.

Ответ 4

Исключения не должны использоваться для логических тестов

Принятый ответ действительно является страшным ответом на вопрос, как его спрашивают, поскольку он нарушает предписание "использовать исключения для исключительных случаев".

Исключения - отличный инструмент для обработки исключительных случаев - случаев, когда что-то действительно пошло не так. Они являются плохими инструментами для существующих прецедентов. Отчасти потому, что бросать и ловить исключение дорого, а отчасти потому, что это вводящий в заблуждение код - когда разработчик видит исключение, он должен разумно иметь возможность предположить, что что-то идет не так. Хороших обсуждений по этому основному принципу изобилуют, но мне нравится "Прагматический программист", или это не плохо: http://www.lohmy.de/2013/03/06/writing-use-cases-exception-or-alternate-flow/

Используйте boost:: lexical_cast, если вы всегда ожидаете число

boost:: lexical_cast - это оптимальное решение, когда оно действительно является исключением для получения нечетного числа.

Использовать boost:: try_lexical_convert, если не-номера являются частью вашего прецедента

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

Фактически, boost предлагает try_lexical_convert, который используется в реализации lexical_cast (взятый из документации здесь: http://www.boost.org/doc/libs/1_58_0/doc/html/boost_lexical_cast/synopsis.html#boost_lexical_cast.synopsis.lexical_cast).

template <typename Target, typename Source>
    inline Target lexical_cast(const Source &arg)
{
    Target result;

    if (!conversion::try_lexical_convert(arg, result))
        throw bad_lexical_cast();

    return result;
}

Ответ 5

До того, как был выпущен boost lexical_cast, я использовал следующее:

namespace detail {

    template< typename Target, typename Source >
    struct stream_caster {
        static Target stream_cast(const Source& s)
        {
            std::stringstream ss;
            if( (ss << s).fail() ) {
                throw std::bad_cast("could not stream from source");
            }
            Target t;
            if( (ss >> t).fail() || !(ss >> ws).eof) {
                throw std::bad_cast("could not stream to target");
            }
            return t;
        }
    };

    template< typename T >
    struct stream_caster<T,T> {
        static const T& stream_cast(const T& s)
        {
            return s;
        }
    };

    template< typename Source >
    struct stream_caster<std::string,Source> {
        static std::string stream_cast(const Source& s)
        {
            std::ostringstream oss;
            if( (oss << s).fail() ) {
                throw std::bad_cast("could not stream from source");
            }
            return oss.str();
        }
    };

    template< typename Target >
    struct stream_caster<Target,std::string> {
        static Target stream_cast(const std::string& s)
        {
            std::stringstream ss(s);
            Target t;
            if( (ss >> t).fail() || !(ss >> ws).eof) {
                throw std::bad_cast("could not stream to target");
            }
            return t;
        }
    };

    template<>
    struct stream_caster<std::string,std::string> {
        static const std::string& stream_cast(const std::string& s)
        {
            return s;
        }
    };

}

template< typename Target, typename Source >
inline Target stream_cast(const Source& s)
{
    return detail::stream_caster<Target,Source>::stream_cast(s);
}