C++将std::string和std::wstring转换为数字的函数封装（字符串转数字）

亦凉 2021-11-01 06:08 223阅读 0赞

# **更新：（2019/11/18）** #

**利用C++17新特性，将模板简单化，通过编译期检查来判断输入参数是否有效以及确定转换函数。**

#ifndef STRING_TO_NUMBER_HPP
    #define STRING_TO_NUMBER_HPP
    
    #include <type_traits>
    #include <string>
    
    template<class T>
    using primitive_type = std::decay_t<T>;
    
    template<class StringT>
    using if_std_string = std::enable_if_t<std::is_same_v<StringT, std::string>, StringT>;
    
    template<class StringT>
    using if_std_wstring = std::enable_if_t<std::is_same_v<StringT, std::wstring>, StringT>;
    
    template<class StringT>
    using if_std_string_or_wstring = std::enable_if_t<std::disjunction_v<
        std::is_same<StringT, std::string>, std::is_same<StringT, std::wstring>>, StringT>;
    
    template<class T>
    using if_signed = std::enable_if_t<std::is_signed_v<T>, T>;
    
    template<class T>
    using if_unsigned = std::enable_if_t<std::is_unsigned_v<T>, T>;
    
    template<class NumberT>
    using if_interger = std::enable_if_t<std::is_integral_v<NumberT>, NumberT>;
    
    template<class NumberT>
    using if_floating_point = std::enable_if_t<std::is_floating_point_v<NumberT>, NumberT>;
    
    template<class NumberT>
    using if_signed_interger = std::enable_if_t< std::conjunction_v<
        std::is_integral<NumberT>, std::is_signed<NumberT>>>;
    
    template<class NumberT>
    using if_unsigned_interger = std::enable_if_t< std::conjunction_v<
        std::is_integral<NumberT>, std::is_unsigned<NumberT>>>;
    
    template<class StringT, class NumberT, bool Except = true,
        class = if_std_string_or_wstring<StringT>, 
        class = if_interger<primitive_type<NumberT>>>
    primitive_type<NumberT> stringToNumber(const StringT& str, std::size_t* pos = 0, int base = 0) noexcept(!Except)
    {
        try {
            if constexpr (std::is_signed_v<primitive_type<NumberT>>) {
                if constexpr (sizeof(NumberT) <= sizeof(long)) {
                    return static_cast<primitive_type<NumberT>>(std::stoi(str, pos, base));
                }
                else if constexpr (sizeof(NumberT) == sizeof(long)) {
                    return static_cast<primitive_type<NumberT>>(std::stol(str, pos, base));
                }
                else {
                    return static_cast<primitive_type<NumberT>>(std::stoll(str, pos, base));
                }
            }
            else {
                if constexpr (sizeof(NumberT) <= sizeof(unsigned long)) {
                    return static_cast<primitive_type<NumberT>>(std::stoul(str));
                }
                else {
                    return static_cast<primitive_type<NumberT>>(std::stoull(str));
                }
            }
        }
        catch (...) {
            if constexpr (Exception) {
                throw;
            }
            else {
                return primitive_type<NumberT>(0);
            }
        }
    }
    
    template<class StringT, class NumberT, bool Except= true,
        class = if_std_string_or_wstring<StringT>, 
        class = if_floating_point<primitive_type<NumberT>>>
    primitive_type<NumberT> stringToNumber(const StringT& str, std::size_t* pos = 0) noexcept(!Except)
    {
        try {
            if constexpr (std::is_same_v<primitive_type<NumberT>, float>) {
                return std::stof(str, pos);
            }
            else if constexpr (std::is_same_v<primitive_type<NumberT>, double>) {
                return std::stod(str, pos);
            }
            else {
                return std::stold(str, pos);
            }
        }
        catch (...) {
            if constexpr (Exception) {
                throw;
            }
            else {
                return primitive_type<NumberT>(0.);
            }
        }
    }
    
    #endif // STRING_TO_NUMBER_HPP

# ** ** #

--------------------

# **以前的实现方式：** #

# **一  说明** #

对于字符串转数字，C++标准库里为我们提供了诸如std::stoi、std::stol、std::stoul、std::stoll、std::stoull、std::stof、std::stod、std::stold等函数，当然还有处理C风格字符串（char \*）的std::atoi、 std::atol、std::atoll、std::atof、std::strtol、 std::strtoll、std::strtoul、std::strtoull、std::strtof, std::strtod, std::strtold...

为了使用方便，博主将std::string、std::wstring转字符串封装成了两个函数：

（1）首先是toNumber()，使用函数模板全特化，使之能根据模板类型自动推导出使用具体的哪一个std::sto\*函数。

（2）第二个函数是toNumberEx()，其主要目的在于使模板参数指定的类型退化。详细解答请看第二部分。

由于函数体短小，将之设为inline最好不过了。

# 二  疑问解答 #

**1. 既然此函数也需要指定目标数字类型，那么为什么要花力气再次封装而不直接使用标准库函数呢，是袁隆平老先生做错了让我们吃太饱了吗？显然不是。**

**   答：** 原因主要有两个：

（1）我们经常使用typedef为某个类型取一个别名，如typedef pay\_t int （额，吉利点还是typedef pay\_t unsigned int吧)。这时我们使用标准库std::stoul函数来进行转换，但是如果哪天老板涨工资了，发现unsigned int已经容不下你的工资了（程序猿一天干嘛 除了代码、游戏就是白日梦，女朋友之类的不存在的，需要的时候new一个就得了），需要unsigned long或者unsigned long long了（虽然我们希望工资越多越好，但是代码是我们的本钱，还是需要有限考虑内存），这时候我们可能就需要将std::stoul替换为std::stoull，如果转换较多的话，每一个都去替换实在是麻烦，于是乎你会发现还是这个函数好啊。

（2）我们可以使用decltype()来推导变量的类型，使其作为模板参数，这样我们又可以不依赖变量类型了。

**2. 异常安全吗？**

**  答：**函数仅仅支持将字符串转换为常用数字类型（short，unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, float, double, long double）,若模板参数传入了其它类型，将抛出std::invalid\_argument异常。

**3. 为什么要定义toNumberEx()函数，其用在什么情况下？**

**  答：**封装Ex()函数的目的在于将类型退化，比如下面一段代码：

using pay_t = typename unsigned int;
    const pay_t pay = 0;
    std::string pay_str = "1000000";
    auto my_pay = toNumber<decltype(pay)>(pay_str); // Error

将抛出std::invalid\_argument("\\\\fn\[toNumber(str)\] invalid template argument.")异常，为什么呢？因为decltype(pay)推导出的类型为const unsigned int, 但是我们提供的函数种并没有全特化这个类型。当然，我们调用std::decay处理也是可以的，如：

using pay_t = typename unsigned int;
    const pay_t pay = 0;
    std::string pay_str = "1000000";
    auto my_pay = toNumber<std::decay_t<decltype(pay)>>(pay_str); // OK

于是乎，博主为了编写代码时偷懒，干脆封装一个toNumberEx()函数。于是乎，上面的代码段就可以这样写了：

using pay_t = typename unsigned int;
    const pay_t pay = 0;
    std::string pay_str = "1000000";
    auto my_pay = toNumberEx<decltype(pay)>(pay_str); // OK

**4. 为什么有这么多个重载函数？**

因为函数模板的显式专用化或实例化（全特化）不能有任何默认参数，所以我们就需要为每种情况都定义一次了，

各位看官还有什么问题，评论留言即可，大家共同交流，共同成长。

# **三  源代码** #

/*!
     * \file	StringToNumber.h
     * \brief	The template functions for std::string/std::wstring convert to number.
     * \date	2019-08-09
     * \author	shaoguang
     */
    
    #include <string>
    
    // 如果失败，抛出std::logic_error异常，具体为std::invalid_argument或std::out_of_range。
    
    /*****************************************************************************
    	toNumber(str, pos, base) ==>
    		short, ushort, int, uint, long, ulong,
    		long long, ulonglong
     *****************************************************************************/
    
    template<typename T>
    inline T toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	throw std::invalid_argument("\\fn[toNumber(str, pos, base)] invalid template argument.");
    }
    template<typename T>
    inline T toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	throw std::invalid_argument("\\fn[toNumber(str, pos, base)] invalid template argument.");
    }
    
    template<>
    inline short toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return static_cast<short>(std::stoi(str, pos, base));
    }
    template<>
    inline short toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return static_cast<short>(std::stoi(str, pos, base));
    }
    
    template<>
    inline unsigned short toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return static_cast<unsigned short>(std::stoul(str, pos, base));
    }
    template<>
    inline unsigned short toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return static_cast<unsigned short>(std::stoul(str, pos, base));
    }
    
    template<>
    inline int toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return std::stoi(str, pos, base);
    }
    template<>
    inline int toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return std::stoi(str, pos, base);
    }
    
    template<>
    inline unsigned int toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return static_cast<unsigned int>(std::stoul(str, pos, base));
    }
    template<>
    inline unsigned int toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return static_cast<unsigned int>(std::stoul(str, pos, base));
    }
    
    template<>
    inline long toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return std::stol(str, pos, base);
    }
    template<>
    inline long toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return std::stol(str, pos, base);
    }
    
    template<>
    inline unsigned long toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return std::stoul(str, pos, base);
    }
    template<>
    inline unsigned long toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return std::stoul(str, pos, base);
    }
    
    template<>
    inline long long toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return std::stoll(str, pos, base);
    }
    template<>
    inline long long toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return std::stoll(str, pos, base);
    }
    
    template<>
    inline unsigned long long toNumber(const std::string &str, std::size_t *pos, int base)
    {
    	return std::stoull(str, pos, base);
    }
    template<>
    inline unsigned long long toNumber(const std::wstring &str, std::size_t *pos, int base)
    {
    	return std::stoull(str, pos, base);
    }
    
    /*****************************************************************************
    	toNumber(str, pos) ==>
    		short, ushort, int, uint, long, ulong,
    		long long, ulonglong, float, double, long double
     *****************************************************************************/
    
    template<typename T>
    inline T toNumber(const std::string &str, std::size_t *pos)
    {
    	throw std::invalid_argument("\\fn[toNumber(str, pos)] invalid template argument.");
    }
    template<typename T>
    inline T toNumber(const std::wstring &str, std::size_t *pos)
    {
    	throw std::invalid_argument("\\fn[toNumber(str, pos)] invalid template argument.");
    }
    
    template<>
    inline short toNumber(const std::string &str, std::size_t *pos)
    {
    	return static_cast<short>(std::stoi(str, pos));
    }
    template<>
    inline short toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return static_cast<short>(std::stoi(str, pos));
    }
    
    template<>
    inline unsigned short toNumber(const std::string &str, std::size_t *pos)
    {
    	return static_cast<unsigned short>(std::stoul(str, pos));
    }
    template<>
    inline unsigned short toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return static_cast<unsigned short>(std::stoul(str, pos));
    }
    
    template<>
    inline int toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stoi(str, pos);
    }
    template<>
    inline int toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stoi(str, pos);
    }
    
    template<>
    inline unsigned int toNumber(const std::string &str, std::size_t *pos)
    {
    	return static_cast<unsigned int>(std::stoul(str, pos));
    }
    template<>
    inline unsigned int toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return static_cast<unsigned int>(std::stoul(str, pos));
    }
    
    template<>
    inline long toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stol(str, pos);
    }
    template<>
    inline long toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stol(str, pos);
    }
    
    template<>
    inline unsigned long toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stoul(str, pos);
    }
    template<>
    inline unsigned long toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stoul(str, pos);
    }
    
    template<>
    inline long long toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stoll(str, pos);
    }
    template<>
    inline long long toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stoll(str, pos);
    }
    
    template<>
    inline unsigned long long toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stoull(str, pos);
    }
    template<>
    inline unsigned long long toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stoull(str, pos);
    }
    
    template<>
    inline float toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stof(str, pos);
    }
    template<>
    inline float toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stof(str, pos);
    }
    
    template<>
    inline double toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stod(str, pos);
    }
    template<>
    inline double toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stod(str, pos);
    }
    
    template<>
    inline long double toNumber(const std::string &str, std::size_t *pos)
    {
    	return std::stold(str, pos);
    }
    template<>
    inline long double toNumber(const std::wstring &str, std::size_t *pos)
    {
    	return std::stold(str, pos);
    }
    
    /*****************************************************************************
    	toNumber(str) ==>
    		short, ushort, int, uint, long, ulong,
    		long long, ulonglong, float, double, long double
     *****************************************************************************/
    
    template<typename T>
    inline T toNumber(const std::string &str)
    {
    	throw std::invalid_argument("\\fn[toNumber(str)] invalid template argument.");
    }
    template<typename T>
    inline T toNumber(const std::wstring &str)
    {
    	throw std::invalid_argument("\\fn[toNumber(str)] invalid template argument.");
    }
    
    template<>
    inline short toNumber(const std::string &str)
    {
    	return static_cast<short>(std::stoi(str));
    }
    template<>
    inline short toNumber(const std::wstring &str)
    {
    	return static_cast<short>(std::stoi(str));
    }
    
    template<>
    inline unsigned short toNumber(const std::string &str)
    {
    	return static_cast<unsigned short>(std::stoul(str));
    }
    template<>
    inline unsigned short toNumber(const std::wstring &str)
    {
    	return static_cast<unsigned short>(std::stoul(str));
    }
    
    template<>
    inline int toNumber(const std::string &str)
    {
    	return std::stoi(str);
    }
    template<>
    inline int toNumber(const std::wstring &str)
    {
    	return std::stoi(str);
    }
    
    template<>
    inline unsigned int toNumber(const std::string &str)
    {
    	return static_cast<unsigned int>(std::stoul(str));
    }
    template<>
    inline unsigned int toNumber(const std::wstring &str)
    {
    	return static_cast<unsigned int>(std::stoul(str));
    }
    
    template<>
    inline long toNumber(const std::string &str)
    {
    	return std::stol(str);
    }
    template<>
    inline long toNumber(const std::wstring &str)
    {
    	return std::stol(str);
    }
    
    template<>
    inline unsigned long toNumber(const std::string &str)
    {
    	return std::stoul(str);
    }
    template<>
    inline unsigned long toNumber(const std::wstring &str)
    {
    	return std::stoul(str);
    }
    
    template<>
    inline long long toNumber(const std::string &str)
    {
    	return std::stoll(str);
    }
    template<>
    inline long long toNumber(const std::wstring &str)
    {
    	return std::stoll(str);
    }
    
    template<>
    inline unsigned long long toNumber(const std::string &str)
    {
    	return std::stoull(str);
    }
    template<>
    inline unsigned long long toNumber(const std::wstring &str)
    {
    	return std::stoull(str);
    }
    
    template<>
    inline float toNumber(const std::string &str)
    {
    	return std::stof(str);
    }
    template<>
    inline float toNumber(const std::wstring &str)
    {
    	return std::stof(str);
    }
    
    template<>
    inline double toNumber(const std::string &str)
    {
    	return std::stod(str);
    }
    template<>
    inline double toNumber(const std::wstring &str)
    {
    	return std::stod(str);
    }
    
    template<>
    inline long double toNumber(const std::string &str)
    {
    	return std::stold(str);
    }
    template<>
    inline long double toNumber(const std::wstring &str)
    {
    	return std::stold(str);
    }
    
    /*****************************************************************************
    	toNumberEx()
    	为了能保证使用decltype推导出正确的类型
    	例:
    		const int a = 0;
    		String str = "2";
    		auto b = strToNumber<decltype(a)>(str); // decltype(a)为const int
    		// b的类型为int
    
    	如果使用
    		toNumber<decltype(a)>(str). // decltype(a)为const int
    	则抛出异常。
     *****************************************************************************/
    
    template<typename T>
    inline std::decay_t<T> toNumberEx(const std::string &str, std::size_t *pos, int base)
    {
    	return toNumber<std::decay_t<T>>(str, pos, base);
    }
    template<typename T>
    inline std::decay_t<T> toNumberEx(const std::wstring &str, std::size_t *pos, int base)
    {
    	return toNumber<std::decay_t<T>>(str, pos, base);
    }
    
    template<typename T>
    inline std::decay_t<T> toNumberEx(const std::string &str, std::size_t *pos)
    {
    	return toNumber<std::decay_t<T>>(str, pos);
    }
    template<typename T>
    inline std::decay_t<T> toNumberEx(const std::wstring &str, std::size_t *pos)
    {
    	return toNumber<std::decay_t<T>>(str, pos);
    }
    
    template<typename T>
    inline std::decay_t<T> toNumberEx(const std::string &str)
    {
    	return toNumber<std::decay_t<T>>(str);
    }
    template<typename T>
    inline std::decay_t<T> toNumberEx(const std::wstring &str)
    {
    	return toNumber<std::decay_t<T>>(str);
    }