C++自定义的工具函数

my_function.h

#pragma once
#include <iostream>
#include <cstdarg>
#include <list>
#include <limits>
#include <vector>
#include <codecvt>
#include <cstdlib>
#include <comdef.h>
#include <string>

#ifndef MY_FUNCTION_H_
#undef max            //取消max的宏定义，他是由comdef.h带进来的，会干扰正常编译
#define MY_FUNCTION_H_
namespace MY_TOOLS {
    /*
    * 专用于输入double类型的变量；处理用户输入，确保用户输入的是合法数字；对于数字和字符混合的输入，数字在前的读取数字，后续的字符丢弃；若是字符在前，则要求重新输入
    * 返回int值EXIT_SUCCESS
    * result_int：用于存放用户输入的整型数字，double*指针，对应的存放空间必须在调用之前分配好；
    * hint_str：const char*指针，用于提示输入的字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    */
    int in_double(double& result_int, const char* hint_str, const char* error_message = {});
    /*
    * 处理用户输入，只处理char字符数组；
    * result_str：char*指针，用于存放用户输入的字符，对应的存放空间必须在调用之前分配好；
    * len：无符号整型，用于指定result_str最多能存储多少个字符（不包括NULL），也就是说，若是result_str能存放10个字符，那么len最多只能传递9；len的最大允许范围为0~(UINT_MAX-1)
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下（长度过长，或者输入为空），提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    * 输入成功会返回EXIT_SUCCESS
    * 在len的值等于UINT_MAX时会返回EXIT_FAILURE
    */
    int in_charArray(char* result_str, unsigned int len, const char* hint_str, const char* error_message = {});
    /*
    * 处理用户输入，专用于输入单个字符；对于输入了多个字符的输入，只取第一个字符，后续字符全部丢弃
    * result_str：char*指针，用于存放用户输入的字符，对应的存放空间必须在调用之前分配好；
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下（长度过长，或者输入为空），提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    * 输入成功会返回EXIT_SUCCESS
    * 在len的值等于UINT_MAX时会返回EXIT_FAILURE
    */
    int in_char(char& result_char, const char* hint_str, const char* error_message = {});
    /*
    * 处理用户输入，专用于输入单个宽字符；对于输入了多个字符的输入，只取第一个字符，后续字符全部丢弃
    * result_str：char*指针，用于存放用户输入的字符，对应的存放空间必须在调用之前分配好；
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下（长度过长，或者输入为空），提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    * 输入成功会返回EXIT_SUCCESS
    * 在len的值等于UINT_MAX时会返回EXIT_FAILURE
    */
    int in_wchar_t(wchar_t& result_char, const wchar_t* hint_str, const wchar_t* error_message = {});
    /*
    * in_uint：处理用户输入，确保用户输入的是正整数；
    * result_int：用于存放用户输入的整型数字，unsigned int*指针，对应的存放空间必须在调用之前分配好；
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    */
    int in_uint(unsigned int& result_int, const char* hint_str, const char* error_message = {});
    /*
    * in_int：处理用户输入，确保用户输入的是整数；
    * result_int：用于存放用户输入的整型数字，int*指针，对应的存放空间必须在调用之前分配好；
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    */
    int in_int(int& result_int, const char* hint_str, const char* error_message = {});
    /*
    * in_long：处理用户输入，确保用户输入的是整数；
    * result_int：用于存放用户输入的整型数字，int*指针，对应的存放空间必须在调用之前分配好；
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    */
    long in_long(long& result_int, const char* hint_str, const char* error_message = {});
    /*
    * 函数功能：简单实现类似于python 中的format功能；该函数将会重载，以适应不同的情况；
    * 注意，你需要保证，args不定数量参数中的每个参数都要为const char*类型；
    * 注意：你需要保证，str中的{}数量与args中参数的数量对应，否则会触发未定义行为。
    * 使用示例：std::cout << MY_IN::format("我的名字：{}。{}", "aaa","今天阳光明媚！\n");
    */
    std::string format(const std::string str, ...);
    /*
    * 注意：宽字符版本format实现很有难度，这里没有实现，建议使用对应的swprintf
    * 函数功能：简单实现类似于python 中的format功能；该函数将会重载，以适应不同的情况；
    * 注意，你需要保证，args不定数量参数中的每个参数都要为const wchar_t*类型；
    * 注意：你需要保证，str中的{}数量与args中参数的数量对应，否则会触发未定义行为。
    * 使用示例：std::wcout << MY_IN::format(L"我的名字：{}。{}", L"aaa",L"今天阳光明媚！\n");
    */
    std::wstring format(const wchar_t* str, ...);

    /*
    * in_uint_scope：处理用户输入，确保用户输入的是正整数，且输入的值处于指定范围内；
    * result_int：    用于存放用户输入的整型数字，unsigned int*指针，对应的存放空间必须在调用之前分配好；
    * start_num:    范围的起始值，若是start_num大于等于end_num，函数将抛出异常（ L"起始值大于等于截止值！"）
    * end_num:        范围的结束值，范围将包含该结束值；
    * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
    * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
    */
    int in_uint_scope(unsigned int& result_int, unsigned int start_num, unsigned int end_num, const char* hint_str, const char* error_message = {});
    /*
    * 变大写，将给定的wstring、string、char数组、wchar_t数组里面的字母变为大写字母
    * 直接修改原来的变量
    * 目前只支持char和wchar_t类型的字符
    * value：需要变大写的变量，引用方式
    * start_index：从哪里开始修改
    * numberOfChar：修改多少个字符
    */
    template<typename T>
    void toUppercase(T& value, unsigned start_index, unsigned numberOfChar) {
        //判断是哪种字符
        if (sizeof(value[0]) == sizeof(char)) {
            for (unsigned i = start_index; i < numberOfChar; i++) {
                value[i] = toupper(value[i]);
            }
        }
        else if (sizeof(value[0]) == sizeof(wchar_t)) {
            for (unsigned i = start_index; i < numberOfChar; i++) {
                value[i] = towupper(value[i]);
            }
        }
        else {
            ;
        }
    }

    /*string字符串分割函数：split
    * 返回list对象
    * value：表示被分割的字符串
    * character：分隔符
    * len：字符串长度
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::list<std::string>split(const std::string value, char character, size_t len);

    /*wstring字符串分割函数：split
    * 返回list对象
    * value：表示被分割的字符串
    * character：分隔符
    * len：字符串长度
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::list<std::wstring>split(const std::wstring value, wchar_t character, size_t len);
    /*wstring字符串分割函数：split_vector：返回类型为vector
    * 返回vector对象
    * value：表示被分割的字符串
    * character：分隔符
    * len：字符串长度
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::vector<std::wstring>split_vector(std::wstring& value, wchar_t character, size_t len);
    /*wstring字符串分割函数：split_vector：返回类型为vector
    * 返回vector对象
    * value：表示被分割的字符串，传递wchar_t*类型
    * character：分隔符
    * len：字符串长度
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::vector<std::wstring>split_vector(const wchar_t* value, wchar_t character, size_t len);
    /*返回list对象的第几个值
    * 若是下标越界，将返回一个默认初始化的T对象，同时将is_success置为false
    * List：list对象
    * index：下标，从0开始
    * is_success：执行是否成功；输出参数
    */
    template<typename T>
    const T list_at(std::list<T> List, unsigned index, bool* is_success = nullptr) {
        if (index >= List.size()) {
            if (is_success) {
                *is_success = false;
            }
            return T{};
        }
        else {
            T ret{};
            unsigned i{};
            for (auto& v : List) {
                if (i == index) {
                    ret = v;
                    break;
                }
                i++;
            }
            return ret;
        }
    }
    /*保留两位小数
    * 数字字符串保留两位小数
    * str：数字字符串
    * num：保留小数的位数，默认为2
    * isCarry：是否进位，默认尝试进位
    * 分为两种方式，一个是尝试进位的方式保留两位小数，另外一种是不管能否进位，直接截断，以达到保留两位小数的目的，若是原字符串长度不够，比如传递过来0.9这样的，那么会原样返回。
    */
    std::wstring  two_decimal_places(const std::wstring& str, unsigned num = 2, bool isCarry = true);
    /*检查给定值是否在后者中；若是存在，则返回给定值所在的下标（从0开始），否则返回-1
    * T1元素位于T2中，比如：T1是int，那么T2应该是stl中的某种容器，比如vector<int>
    */
    template<typename T1, typename T2>
    int isExist(T1 t1, T2 t2) {
        bool flag{};
        int index{};
        for (auto& v : t2) {
            if (t1 == v) {
                flag = true;
                return index;
            }
            index++;
        }
        if (!flag) {
            return -1;
        }
        else {
            return index;
        }
    }
    /*
    * wstring版本的replace函数，主要是实现在给定的范围内，将replaced_str替换成value_str，is_all表示是否替换所有的replaced_str；
    * 注：是直接在源字符串上操作；
    * str：源字符串
    * first：size_t，指向开始范围；
    * strLen：size_t，范围的长度；
    * replaced_str：被替换的字符（串）
    * value_str：目标字符（串）
    * is_all：为true时表示替换给定范围内的所有replaced_str；为false的时候表示只替换一次（如果存在匹配）；
    */
    std::wstring& replace(std::wstring& str, size_t first, size_t strLen, const std::wstring replaced_str, const std::wstring value_str, bool is_all);
    /*
    * string版本的replace函数，主要是实现在给定的范围内，将replaced_str替换成value_str，is_all表示是否替换所有的replaced_str；
    * 注：并不直接修改源字符串
    * str：源字符串
    * first：size_t，指向开始范围；
    * strLen：size_t，范围的长度；
    * replaced_str：被替换的字符（串）
    * value_str：目标字符（串）
    * is_all：为true时表示替换给定范围内的所有replaced_str；为false的时候表示只替换一次（如果存在匹配）；
    */
    std::string replace(std::string& str, size_t first, size_t strLen, const std::string replaced_str, const std::string value_str, bool is_all);
    /*
    * 循环左移函数：将数字类型的变量类型（int,long,long long等）的二进制循环左移
    * 注：只针对基础类型，不支持对象类型
    * source：被循环左移的变量
    * num：循环的位数，你应该确保num小于source的二进制位数
    */
    template<typename T>
    T ring_shift_left(T source, int num) {
        int binary_len = sizeof(T) * 8;
        if (binary_len == num) {
            return source;
        }
        else if (binary_len < num)
        {
            num = num % binary_len;
        }

        T a = source << num;
        T b = source >> (binary_len - num);
        T result = a | b;
        return result;
    }

    /*
    * vector<char>转为string
    */
    std::string vecChar_to_string(std::vector<char>& source);
    /*
    * vector<unsigned char>转为string
    */
    std::string vecUChar_to_string(std::vector<unsigned char>& source);

    /*
    * 打印可选普通字符串optstr后,跟集合的所有元素（要求能使用cout正常输出的）,并用指定的字符分隔在一行中
    * coll：待输出的元素集合
    * delimiter：分隔符
    * optstr：说明字符串
    */
    template<typename T>
    inline void PRINT_ELEMENTS(const T& coll, const std::string& delimiter = "", const std::string& optstr = "") {
        std::cout << optstr;
        for (const auto& elem : coll) {
            std::cout << elem << delimiter;
        }
        std::cout << std::endl;
    }
    /*
    * 打印可选宽字符串optstr后,跟集合的所有元素（要求能使用wcout正常输出的）,并用指定的字符分隔在一行中
    * coll：待输出的元素集合
    * delimiter：分隔符
    * optstr：说明字符串
    */
    template<typename T>
    inline void PRINT_ELEMENTS_W(const T& coll, const std::wstring& delimiter = L"", const std::wstring& optstr = L"") {
        std::locale::global(std::locale(""));    //本地化
        std::wcout << optstr;
        for (const auto& elem : coll) {
            std::wcout << elem << delimiter;
        }
        std::wcout << std::endl;
    }
    /*
    * stirng转wstring
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::wstring string2wstring(std::string str);
    /*
    * wstring转string
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::string wstring2string(std::wstring wstr);
    /*
    * 字符串转数字，单个转换版本；
    * 本函数会尽可能将字符转换为数字，若是所遇的第一个字符不是标明的忽略字符，将转换失败，设置result参数为false。
    * source：待转换的字符
    * neglect：需要忽略的开头的字符
    * result：标志本次转换是否成功
    * hexadecimal：进制数，默认为10
    * 返回值：返回成功转换的结果数值，若是转换失败，返回值为0；
    * 注：应该在函数执行完成后，检查result参数的值，为true表示成功，否则表示失败
    *    开头的空白符会自动跳过
    */
    long long string_to_value(const std::string source, std::string neglect, bool* result, unsigned hexadecimal = 10);

    //将string转换为wstring
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::wstring to_wstring(const std::string& str, const std::locale& loc = std::locale());
    //将wstring转换为string，使用'?`作为默认字符
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::string to_string(const std::wstring& str, const std::locale& loc = std::locale());
    //转换UTF-8字符串为wstring
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::wstring utf8_to_wstring(const std::string& str);
    //将wstring转换为UTF-8字符串
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::string wstring_to_utf8(const std::wstring& str);
    /*
    * 删除字符串开头的空格，制表符
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::string remove_leading_whitespace(std::string str);
    /*
    * 删除字符串开头的空格，制表符
    */
    [[nodiscard("不可以忽略该函数的返回值，否则函数动作无效")]] std::wstring remove_leading_whitespace(std::wstring str);
}

#endif // !MY_FUNCTION_H_

 

my_function.cpp

#include "my_function.h"

namespace MY_TOOLS {
    int in_double(double& result_int, const char* hint_str, const char* error_message) {
        double a;
        while (true)
        {
            std::cout << hint_str;

            if (std::cin >> a) {
                std::cin.get();     //cin不处理回车符
                result_int = a;
                break;
            }
            else {
                if (nullptr != error_message) {
                    std::cout << error_message;
                }
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
        }
        return EXIT_SUCCESS;
    }
    int in_charArray(char* result_str, unsigned int len, const char* hint_str, const char* error_message) {
        std::string a;
        if (UINT_MAX == len) {
            std::cout << "参数len的值为UINT_MAX！";
            return EXIT_FAILURE;
        }
        while (true)
        {
            std::cout << hint_str;

            if (std::getline(std::cin, a)) {
                if (a.size() <= len) {
                    const char* b = a.c_str();
                    strncpy_s(result_str, len + 1, b, len);
                    /*
                    * errno_t strncpy_s(   char *strDest,   size_t numberOfElements,   const char *strSource,   size_t count);
                    * 函数在内部处理的时候，会因为要保留NULL字符，将numberOfElements减去1，就是说，numberOfElements最小值应该为2，否则就会触发参数无效异常
                    */
                    *(result_str + len) = NULL;
                    break;
                }
                else {
                    if (nullptr == error_message) {
                        std::cout << "你输入的字符串太长了，超过了" << len << "。重新输入。" << std::endl;
                        a = "";
                    }
                    else {
                        std::cout << error_message;
                        a = "";
                    }

                }
            }
            else {
                //对于输入字符类型，这个应该是有点多余的。
                std::cin.clear();
                //std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行 ,但是若是输入缓冲区为空，就会阻塞，等待缓冲区有值才会执行。
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
        }
        return EXIT_SUCCESS;
    }
    int in_uint(unsigned int& result_int, const char* hint_str, const char* error_message) {
        long long a;
        while (true)
        {
            std::cout << hint_str;

            if (std::cin >> a) {
                std::cin.get();     //cin不处理回车符
                if (a >= 0 && a <= UINT_MAX) {
                    result_int = static_cast<unsigned int>(a);
                    break;
                }
            }
            else {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
            if (nullptr == error_message) {
                std::cout << "请输入正整数！\n";
            }
            else {
                std::cout << error_message;
            }
        }
        return EXIT_SUCCESS;
    }
    int in_int(int& result_int, const char* hint_str, const char* error_message) {
        int a;
        while (true)
        {
            std::cout << hint_str;

            if (std::cin >> a) {
                result_int = a;
                std::cin.get();     //cin不处理回车符
                break;
            }
            else {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
            if (nullptr == error_message) {
                std::cout << "请输入整数！";
            }
            else {
                std::cout << error_message;
            }
        }
        return EXIT_SUCCESS;
    }
    std::string  format(const std::string str, ...) {
        va_list args;
        va_start(args, str);
        std::string result_str = str;
        size_t index = result_str.find("{}", 0);
        const char* value{};
        while (index != std::string::npos)
        {
            value = va_arg(args, const char*);

            result_str.replace(index, 2, value);

            index = result_str.find("{}", 0);
        }
        va_end(args);

        return result_str;
    }

    long in_long(long& result_int, const char* hint_str, const char* error_message) {
        long a;
        while (true)
        {
            std::cout << hint_str;

            if (std::cin >> a) {
                result_int = a;
                std::cin.get();     //cin不处理回车符
                break;
            }
            else {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
            if (nullptr == error_message) {
                std::cout << "请输入整数！";
            }
            else {
                std::cout << error_message;
            }
        }
        return EXIT_SUCCESS;
    }
    int in_uint_scope(unsigned int& result_int, unsigned int start_num, unsigned int end_num, const char* hint_str, const char* error_message) {
        if (start_num < end_num) {
            unsigned int a;
            while (true)
            {
                std::cout << hint_str;
                if (std::cin >> a) {
                    if (start_num <= a && a <= end_num) {
                        result_int = a;
                        std::cin.get();     //cin不处理回车符
                        break;
                    }
                    else {
                        std::wcout << L"输入的值应该大于等于" << start_num << L"小于等于" << end_num << L"！\n";
                        std::cin.get();     //cin不处理回车符
                        continue;
                    }
                }
                else {
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                    //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                    //  通过 numeric_limits 模板的特化提供此信息。
                    //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
                }
                if (nullptr == error_message) {
                    std::cout << "请输入整数！";
                }
                else {
                    std::cout << error_message;
                }
            }
            return EXIT_SUCCESS;
        }
        else {
            throw  L"起始值大于等于截止值！";
            //std::wcout << L"起始值大于等于截止值！" << std::endl;
            return EXIT_SUCCESS;
        }
    }
    int in_char(char& result_char, const char* hint_str, const char* error_message) {
        std::string a;
        while (true)
        {
            std::cout << hint_str;

            if (std::getline(std::cin, a)) {
                result_char = a[0];
                break;
            }
            else {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
            if (nullptr == error_message) {
                std::cout << "请输入！";
            }
            else {
                std::cout << error_message;
            }
        }
        return EXIT_SUCCESS;
    }
    int in_wchar_t(wchar_t& result_char, const wchar_t* hint_str, const wchar_t* error_message) {
        std::wstring a;
        while (true)
        {
            std::wcout << hint_str;

            if (std::getline(std::wcin, a)) {
                a += L'\n';         //不能丢弃换行符，因为有时候就是需要它。
                result_char = a[0];
                break;
            }
            else {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
                //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
                //  通过 numeric_limits 模板的特化提供此信息。
                //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
            }
            if (nullptr == error_message) {
                std::wcout << L"请输入！";
            }
            else {
                std::wcout << error_message;
            }
        }
        return EXIT_SUCCESS;
    }
    std::list<std::string>split(const std::string value, char character, size_t len) {
        std::list<std::string> ret;
        unsigned start_index{}, end_index{};
        for (unsigned i{}; i < len; i++) {
            end_index = i;
            if (value[i] == character) {
                ret.push_back(value.substr(start_index, end_index - start_index));
                start_index = end_index + 1;
            }
        }
        ret.push_back(value.substr(start_index, len - start_index));
        return ret;
    }

    std::list<std::wstring>split(const std::wstring value, wchar_t character, size_t len) {
        std::list<std::wstring> ret;
        unsigned start_index{}, end_index{};
        for (unsigned i{}; i < len; i++) {
            end_index = i;
            if (value[i] == character) {
                ret.push_back(value.substr(start_index, end_index - start_index));
                start_index = end_index + 1;
            }
        }
        ret.push_back(value.substr(start_index, len - start_index));
        return ret;
    }
    std::vector<std::wstring>split_vector(std::wstring& value, wchar_t character, size_t len) {
        std::vector<std::wstring> ret;
        unsigned start_index{}, end_index{};
        for (unsigned i{}; i < len; i++) {
            end_index = i;
            if (value[i] == character) {
                ret.push_back(value.substr(start_index, end_index - start_index));
                start_index = end_index + 1;
            }
        }
        ret.push_back(value.substr(start_index, len - start_index));
        return ret;
    }
    std::vector<std::wstring>split_vector(const wchar_t* value, wchar_t character, size_t len) {
        std::vector<std::wstring> ret;
        unsigned start_index{}, end_index{};
        std::wstring value_str = value;
        for (unsigned i{}; i < len; i++) {
            end_index = i;
            if (value[i] == character) {
                ret.push_back(value_str.substr(start_index, end_index - start_index));
                start_index = end_index + 1;
            }
        }
        ret.push_back(value_str.substr(start_index, len - start_index));
        return ret;
    }
    std::wstring  two_decimal_places(const std::wstring& str, unsigned num, bool isCarry) {
        std::wstring cost = str;

        size_t str_index = cost.find('.');
        if (str_index != std::wstring::npos) {
            if (isCarry) {
                if ((str_index + num + 1) < cost.size()) {
                    //长度足够
                    //尝试进位
                    if (cost[str_index + num + 1] > L'4') {
                        //进位
                        bool is_carry{};    //是否需要最终进位，比如99.99进位到100.00；true表示要
                        std::wstring cost_ = cost.substr(0, str_index + num + 1);
                        for (auto rend = cost_.rbegin(); rend < cost_.rend(); rend++) {
                            if (*rend == L'9') {
                                *rend = L'0';
                                is_carry = true;
                            }
                            else {
                                is_carry = false;
                                *rend = ++(*rend);
                                cost = cost_;
                                break;
                            }
                        }
                        if (is_carry) {
                            cost = L'1' + cost_;
                        }
                    }
                    else {
                        //直接截断，保留两位小数
                        cost = cost.substr(0, str_index + 3);
                    }
                }
                else {
                    //长度不足
                    ;
                }
            }
            else {
                if ((str_index + num + 1) < cost.size()) {
                    cost = cost.substr(0, str_index + 3);
                }
            }
        }
        return cost;
    }

    std::wstring& replace(std::wstring& str, size_t first, size_t strLen, const std::wstring replaced_str, const std::wstring value_str, bool is_all) {
        std::wstring result = str.substr(first, strLen);
        if (is_all) {
            size_t index{};
            index = result.find(replaced_str, index);
            size_t replaced_str_len = replaced_str.size();
            while (index != std::wstring::npos)
            {
                result.replace(index, replaced_str_len, value_str);
                index += value_str.length();        //主要是为了防止出现循环替换的情况
                index = result.find(replaced_str, index);
            }
            str.replace(first, strLen, result);
            return str;
        }
        else {
            size_t index = result.find(replaced_str);
            if (index != std::wstring::npos) {
                size_t replaced_str_len = replaced_str.size();
                result.replace(index, replaced_str_len, value_str);
                str.replace(first, strLen, result);
            }
            return str;
        }
    }
    std::string replace(std::string& str, size_t first, size_t strLen, const std::string replaced_str, const std::string value_str, bool is_all) {
        std::string str_sub = str.substr(first, strLen);
        if (is_all) {
            size_t index{};
            index = str_sub.find(replaced_str, index);
            while (index != std::wstring::npos)
            {
                str_sub.replace(index, replaced_str.size(), value_str);
                index += value_str.length();        //主要是为了防止出现循环替换的情况
                index = str_sub.find(replaced_str, index);
            }
        }
        else {
            //只替换一次
            size_t index = str_sub.find(replaced_str);
            if (index != std::wstring::npos) {
                size_t replaced_str_len = replaced_str.size();
                str_sub.replace(index, replaced_str_len, value_str);
            }
        }
        return str_sub;

    }
    std::string vecChar_to_string(std::vector<char>& source) {
        std::string ret;
        for (auto& v : source) {
            ret += static_cast<char>(v);
        }
        return ret;
    }
    std::string vecUChar_to_string(std::vector<unsigned char>& source) {
        std::string ret;
        for (auto& v : source) {
            ret += static_cast<unsigned char>(v);
        }
        return ret;
    }
    std::wstring string2wstring(std::string str) {
        std::wstring result;
        int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, static_cast<int>(0));
        if (len < 0)return result;
        wchar_t* buffer = new wchar_t[len + 1];
        if (buffer == NULL)return result;
        MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, static_cast<int>(len));
        buffer[len] = '\0';
        result.append(buffer);
        delete[] buffer;

        return result;
    }
    std::string wstring2string(std::wstring wstr)
    {
        std::string result;
        int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), NULL, 0, NULL, NULL);
        if (len <= 0)return result;
        char* buffer = new char[len + 1];
        if (buffer == NULL)return result;
        WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), buffer, len, NULL, NULL);
        buffer[len] = '\0';
        result.append(buffer);
        delete[] buffer;

        return result;
    }
    long long string_to_value(const std::string source, std::string neglect, bool* result, unsigned hexadecimal) {
        long long ret{};
        std::string data, temp;
        //删除前面的空格
        unsigned i{};
        for (; i < source.size(); ++i) {
            if (source[i] != ' ') {
                break;
            }
        }
        temp = source.substr(i, source.size() - i);

        if (temp.size() >= neglect.size()) {
            unsigned i{};
            for (; i < neglect.size() && temp[i] == neglect[i]; ++i) {
                ;
            }
            if (i + 1 == neglect.size()) {
                //前缀符合
                data = temp.substr(neglect.size(), temp.size() - neglect.size());
            }
            else {
                data = temp;
            }
        }
        else {
            *result = false;
            return 0;
        }
        try
        {
            ret = std::stoll(data, nullptr, hexadecimal);
            *result = true;
        }
        catch (const std::exception& e)
        {
            *result = false;
            return 0;
        }
        return ret;
    }
    std::wstring to_wstring(const std::string& str, const std::locale& loc) {
        std::vector<wchar_t>buf(str.size());
        std::use_facet<std::ctype<wchar_t>>(loc).widen(str.data(), str.data() + str.size(), buf.data());
        return std::wstring(buf.data(), buf.size());
    }
    std::string to_string(const std::wstring& str, const std::locale& loc) {
        std::vector<char>buf(str.size());
        std::use_facet<std::ctype<wchar_t>>(loc).narrow(str.data(), str.data() + str.size(), '?', buf.data());
        return std::string(buf.data(), buf.size());
    }
    std::wstring utf8_to_wstring(const std::string& str) {
        std::wstring_convert<std::codecvt_utf8 < wchar_t > >myconv;
        return myconv.from_bytes(str);
    }
    std::string wstring_to_utf8(const std::wstring& str)
    {
        std::wstring_convert<std::codecvt_utf8 < wchar_t > >myconv;
        return myconv.to_bytes(str);
    }

    std::string remove_leading_whitespace(std::string str) {
        std::string ret;
        size_t i{};
        for (; i < str.size(); ++i) {
            if (str[i] != ' ' || str[i] != '\t') {
                break;
            }
        }
        ret = str.substr(i, str.size() - i);
        return ret;
    }
    std::wstring remove_leading_whitespace(std::wstring str) {
        std::wstring ret;
        size_t i{};
        for (; i < str.size(); ++i) {
            if (str[i] != L' ' || str[i] != L'\t') {
                break;
            }
        }
        ret = str.substr(i, str.size() - i);
        return ret;
    }
}

 

不定期更新。