ASCII码生成和字符编号获取

有一段时间用ASCII码特别勤，但是我又死活记不住哪些，就写了一个小工具，不过写了之后反而没有用过了。淦~

简单记录一下吧

 

// ascii_code.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
// 本程序生成ASCII序号和对应字符。以后可能会拓展
//

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include "..\my_func\my_function.h"
#include<Windows.h>

std::map<int, wchar_t>html_code{ {161,L'?'},{162,L'￠'},{163,L'￡'},{164,L'¤'},{165,L'￥'},{166,L'|'},{167,L'§'},{168,L'¨'},{169,L'©'},{170,L'a'},{171,L'?'},{172,L'?'},{173,L'­'},{174,L'®'},{175,L'ˉ'},{176,L'°'},{177,L'±'},{178,L'2'},{179,L'3'},{180,L'′'},{181,L'μ'},{182,L'?'},{183,L'·'},{184,L'?'},{185,L'1'},{186,L'o'},{187,L'?'},{188,L'?'},{189,L'?'},{190,L'?'},{191,L'?'},{192,L'À'},{193,L'Á'},{194,L'Â'},{195,L'Ã'},{196,L'Ä'},{197,L'Å'},{198,L'Æ'},{199,L'Ç'},{200,L'È'},{201,L'É'},{202,L'Ê'},{203,L'Ë'},{204,L'Ì'},{205,L'Í'},{206,L'Î'},{207,L'Ï'},{208,L'Ð'},{209,L'Ñ'},{210,L'Ò'},{211,L'Ó'},{212,L'Ô'},{213,L'Õ'},{214,L'Ö'},{215,L'×'},{216,L'Ø'},{217,L'Ù'},{218,L'Ú'},{219,L'Û'},{220,L'Ü'},{221,L'Ý'},{222,L'Þ'},{223,L'ß'},{224,L'à'},{225,L'á'},{226,L'â'},{227,L'ã'},{228,L'ä'},{229,L'å'},{230,L'æ'},{231,L'ç'},{232,L'è'},{233,L'é'},{234,L'ê'},{235,L'ë'},{236,L'ì'},{237,L'í'},{238,L'î'},{239,L'ï'},{240,L'ð'},{241,L'ñ'},{242,L'ò'},{243,L'ó'},{244,L'ô'},{245,L'õ'},{246,L'ö'},{247,L'÷'},{248,L'ø'},{249,L'ù'},{250,L'ú'},{251,L'û'},{252,L'ü'},{253,L'ý'},{254,L'þ'},{255,L'ÿ'} };


const static size_t LEN{ 128 }; //字符范围
/*
* 解析-char参数；此函数只解析参数格式，但是不校验参数是否合乎预期
* source_data：源数据数组指针
* len：source_data的长度
* flag：若是为true，则解析source_data数组。若是为false，则通过命令行提示用户输入
*/
void analyze_char_parameter(char** source_data, unsigned len, bool flag);
/*
* 解析-code参数；此函数只解析参数格式，但是不校验参数是否合乎预期
* source_data：源数据数组指针
* len：source_data的长度
* flag：若是为true，则解析source_data数组。若是为false，则通过命令行提示用户输入
*/
void analyze_code_parameter(char** source_data, unsigned len, bool flag);

/*
* 本函数用于输出显示使用
* code：序号
* ch：字符
* order：输出顺序，默认为true（表示序号在前，字符在后）,为false时则相反
* with：序号宽度，默认为8
* spacer：间隔符，默认为\t
* ending_symbol：结尾符号，默认为\n
*/
void wirte_screen(std::wstring code, wchar_t ch, bool order = true, unsigned with = 8, wchar_t spacer = L'\t', wchar_t ending_symbol = L'\n'); 
/*
* 检查值是否符合预期并调用对应函数输出
* start_index：起始编号(包含）
* end_index：结尾编号（不包含）
* flag：0表示使用常规数字映射字符。1表示使用html映射字符，2表示8进制数，3表示16进制数
*/
bool code_to_char_check(std::string start_index, std::string end_index);
/*
* start_index：起始编号(包含）
* end_index：结尾编号（不包含）
*/
void code_to_char(size_t start_index, size_t end_index);
/*
* str：待转换为code的字符串
* 将字符转换为code输出
*/
/*输出帮助信息*/
void help();
void char_to_code(std::wstring str);
/*
* 有四种模式：
*   默认不传递参数的模式：输出1-128的ASCII码
*   指定参数-code的模式，输出指定code值对应的字符：
        示例：
            -code 68 79     ：输出68和79对应的字符
            -code 68,79     ：输出68和79对应的字符
            -code 68        ：表示输出68对应的字符
            -code 68-79     ：表示输出68到79之间的字符
            -code 66,68-70  ：表示输出66、68到70之间的字符（66,68,69,70）
            -code -128      ：表示输出0-128之间的字符
            -code ,55       ：表示输出55对应的字符
            -code &#161;    ：表示输出&#161;对应的字符?
            -code \0x22;    ：表示输出十六进制数22对应的字符
        说明：
            支持识别html特殊字符的十进制表现形式的转换：
            字符    十进制
            ?    &#161;
            ￠    &#162;
            ￡    &#163;
            ¤    &#164;
            ￥    &#165;
            |    &#166;
            §    &#167;
            ¨    &#168;
            ©    &#169;
            a    &#170;
            ?    &#171;
            ?    &#172;
            /x7f    &#173;
            ®    &#174;
            ˉ    &#175;
            °    &#176;
            ±    &#177;
            2    &#178;
            3    &#179;
            ′    &#180;
            μ    &#181;
            ?    &#182;
            ·    &#183;
            ?    &#184;
            1    &#185;
            o    &#186;
            ?    &#187;
            ?    &#188;
            ?    &#189;
            ?    &#190;
            ?    &#191;
            À    &#192;
            Á    &#193;
            Â    &#194;
            Ã    &#195;
            Ä    &#196;
            Å    &#197;
            Æ    &#198;
            Ç    &#199;
            È    &#200;
            É    &#201;
            Ê    &#202;
            Ë    &#203;
            Ì    &#204;
            Í    &#205;
            Î    &#206;
            Ï    &#207;
            Ð    &#208;
            Ñ    &#209;
            Ò    &#210;
            Ó    &#211;
            Ô    &#212;
            Õ    &#213;
            Ö    &#214;
            ×    &#215;
            Ø    &#216;
            Ù    &#217;
            Ú    &#218;
            Û    &#219;
            Ü    &#220;
            Ý    &#221;
            Þ    &#222;
            ß    &#223;
            à    &#224;
            á    &#225;
            â    &#226
            ã    &#227;
            ä    &#228;
            å    &#229;
            æ    &#230;
            ç    &#231;
            è    &#232;
            é    &#233;
            ê    &#234;
            ë    &#235;
            ì    &#236;
            í    &#237;
            î    &#238;
            ï    &#239;
            ð    &#240;
            ñ    &#241;
            ò    &#242;
            ó    &#243;
            ô    &#244;
            õ    &#245;
            ö    &#246;
            ÷    &#247;
            ø    &#248;
            ù    &#249;
            ú    &#250;
            û    &#251;
            ü    &#252;
            ý    &#253;
            þ    &#254;
            ÿ    &#255;

            参数值中的不符合预期的字符被视为终止符号，将忽视该字符以及该字符后面的字符。
            使用连字符指定范围时，若是后面的数字小于前面的数字，将不会判定为错误，而是视为倒序输出；若是前后两个数字相等，则表示连续输出两个同样的字符
*   指定参数-char的模式，输出指定字符串值对应的code：
        示例：
            -char abcdefg   ：表示依次输出abcdefg每个字符对应的code值
            -char a d       ：表示输出a、空格、d字符对应的code值
*   指定参数-h的模式，输出帮助信息
*
*   注：因为编码的缘故，若是你想要看到完整的Unicode字符的真实编码，需要将Windows电脑的默认字符集设置为Unicode，但是这个开启后会导致部分软件显示不正常。但是部分的中文字符是支持的
*/
int main(int argc, char* argv[]) {
    std::ios::sync_with_stdio(false);// 禁用同步
    std::locale::global(std::locale(""));    //本地化

    /*for (int i{ 0 }; i < argc; ++i) {
        std::cout << argv[i] << '\n';
    }
    std::cout << "完毕\n";*/

    if (argc == 1) {
        //不传递参数模式
        code_to_char(1, 128);
    }
    else {
        //检查是否是需要帮助信息
        if (std::string("-h")._Equal(argv[1])) {
            help();
            exit(0);
        }
        else if (std::string("-char")._Equal(argv[1])) {
            if (argc == 2) {
                analyze_char_parameter(argv, argc, false);
            }
            else {
                analyze_char_parameter(argv, argc, true);
            }
        }
        else if (std::string("-code")._Equal(argv[1])) {
            if (argc == 2) {
                analyze_code_parameter(argv, argc, false);
            }
            else {
                analyze_code_parameter(argv, argc, true);
            }
        }
        else {
            help();
            exit(0);
        }
    }
    
    system("pause");
}
void help() {
    std::wcout << LR"(/*
* 有四种模式：
*   默认不传递参数的模式：输出1-128的ASCII码
*   指定参数-code的模式，输出指定code值对应的字符：
        示例：
            -code 68 79     ：输出68和79对应的字符
            -code 68        ：表示输出68对应的字符
            -code 68-79     ：表示输出68到79之间的字符
            -code 66,68-70  ：表示输出66、68到70之间的字符（66,68,69,70）
            -code -128      ：表示输出0-128之间的字符
            -code ,55       ：表示输出55对应的字符
            -code &#161;    ：表示输出&#161;对应的字符?
            -code \0x22;    ：表示输出十六进制数22对应的字符
        说明：
            支持识别html特殊字符的十进制表现形式的转换：
            
            参数值中的不符合预期的字符被视为终止符号，将忽视该字符以及该字符后面的字符。
            使用连字符指定范围时，若是后面的数字小于前面的数字，将不会判定为错误，而是视为倒序输出；若是前后两个数字相等，则表示连续输出两个同样的字符
*   指定参数-char的模式，输出指定字符串值对应的code：
        示例：
            -char abcdefg   ：表示依次输出abcdefg每个字符对应的code值
            -char a d       ：表示输出a、空格、d字符对应的code值
*   指定参数-h的模式，输出帮助信息
* 
*   注：因为编码的缘故，若是你想要看到完整的Unicode字符的真实编码，需要将Windows电脑的默认字符集设置为Unicode，但是这个开启后会导致部分软件显示不正常。但是部分的中文字符是支持的
*/)" << L'\n';
}
void char_to_code(std::wstring str) {
    for (auto ch : str) {
        wirte_screen(std::to_wstring(static_cast<size_t>(ch)), ch, false);
    }
}
void code_to_char(size_t start_index, size_t end_index) {
    if (start_index <= end_index) {
        for (; start_index <= end_index; ++start_index)
        {
            wirte_screen(std::to_wstring(start_index), static_cast<wchar_t>(start_index));
        }
    }
    else {
        for (; start_index >= end_index; --start_index)
        {
            wirte_screen(std::to_wstring(start_index), static_cast<wchar_t>(start_index));
        }
    }
}
/*
* html版本的code转char，从start_index开始依次递增count个；若是超长，则止步于实际长度的字符数
*/
void htmlCode_to_char(int start_index, int count) {
    //范围是161-255
    int range = start_index + count;
    if (range > 255) {
        range = 255;
    }
    else if (range < 161) {
        range = 161;
    }
    if (count >= 0) {
        for (; start_index <= range; ++start_index) {
            wirte_screen(L"&#" + std::to_wstring(start_index) + L";", html_code[start_index]);
        }
    }
    else {
        //逆序
        for (; start_index >= range; --start_index) {
            wirte_screen(L"&#" + std::to_wstring(start_index) + L";", html_code[start_index]);
        }
    }
}
bool code_to_char_check(std::string start_index, std::string end_index) {
    long long  start_number{}, end_number{};
    //删除前面的空白符
    start_index = MY_TOOLS::remove_leading_whitespace(start_index);
    end_index = MY_TOOLS::remove_leading_whitespace(end_index);
    bool conversion_result{};   //转换结果

    if (start_index[0] == '\\') {
        //8进制或者16进制
        if (end_index[0] == '\\') {
            if (start_index.size() > 2) {
                if (start_index[1] == '0') {
                    //16进制
                    start_number = MY_TOOLS::string_to_value(start_index.substr(1, start_index.size() - 1), "", &conversion_result, 16);
                    if (conversion_result) {
                        if (end_index.size() > 2) {
                            if (end_index[1] == '0') {
                                //16进制
                                end_number = MY_TOOLS::string_to_value(end_index.substr(1, end_index.size() - 1), "", &conversion_result, 16);
                                if (conversion_result) {
                                    code_to_char(start_number, end_number);
                                    return true;
                                }
                                else {
                                    //转换失败
                                    std::wcerr << L"16进制数转换失败，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                                    return false;
                                }
                            }
                            else if (start_index[1] == 'o') {
                                //8进制
                                end_number = MY_TOOLS::string_to_value(end_index.substr(2, end_index.size() - 2), "", &conversion_result, 8);
                                if (conversion_result) {
                                    code_to_char(start_number, end_number);
                                    return true;
                                }
                                else {
                                    //转换失败
                                    std::wcerr << L"8进制数转换失败，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                                    return false;
                                }
                            }
                            else {
                                //错误
                                std::wcerr << L"未知的进制,end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                                return false;
                            }
                        }
                        else {
                            //长度不对
                            std::wcerr << L"长度无法满足，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                            return false;
                        }
                    }
                    else {
                        //转换失败
                        std::wcerr << L"16进制数转换失败，start_index：" << MY_TOOLS::to_wstring(start_index) << L'\n';
                        return false;
                    }
                }
                else if (start_index[1] == 'o') {
                    //8进制
                    start_number = MY_TOOLS::string_to_value(start_index.substr(2, start_index.size() - 2), "", &conversion_result, 8);
                    if (conversion_result) {
                        if (end_index.size() > 2) {
                            if (end_index[1] == '0') {
                                //16进制
                                end_number = MY_TOOLS::string_to_value(end_index.substr(1, start_index.size() - 1), "", &conversion_result, 16);
                                if (conversion_result) {
                                    code_to_char(start_number, end_number);
                                    return true;
                                }
                                else {
                                    //转换失败
                                    std::wcerr << L"16进制数转换失败，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                                    return false;
                                }
                            }
                            else if (start_index[1] == 'o') {
                                //8进制
                                end_number = MY_TOOLS::string_to_value(end_index.substr(2, end_index.size() - 2), "", &conversion_result, 8);
                                if (conversion_result) {
                                    code_to_char(start_number, end_number);
                                    return true;
                                }
                                else {
                                    //转换失败
                                    std::wcerr << L"8进制数转换失败，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                                    return false;
                                }
                            }
                            else {
                                //错误
                                std::wcerr << L"未知的进制,end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                                return false;
                            }
                        }
                        else {
                            //长度不对
                            std::wcerr << L"长度无法满足，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                            return false;
                        }
                    }
                    else {
                        //转换失败
                        std::wcerr << L"8进制数转换失败，start_index：" << MY_TOOLS::to_wstring(start_index) << L'\n';
                        return false;
                    }
                }
                else {
                    //错误
                    std::wcerr << L"未知的进制,start_index：" << MY_TOOLS::to_wstring(start_index) << L'\n';
                    return false;
                }
            }
            else {
                //长度不对
                std::wcerr << L"长度无法满足，start_index：" << MY_TOOLS::to_wstring(start_index) << L'\n';
                return false;
            }
        }
        else {
            //同一次解析遇到前后不一样的情况，视为错误；
            std::wcerr << L"同一次解析遇到前后不一样的情况，视为错误：" << MY_TOOLS::to_wstring(start_index) << L"-" << MY_TOOLS::to_wstring(end_index) << L'\n';
            return false;
        }
    }
    else if (start_index[0] == '&') {
        //html
        if (end_index[0] == '&') {
            if (start_index.size() != 6) {
                std::wcerr << L"start_index：html的十进制数字符个数不为6：" << MY_TOOLS::to_wstring(start_index) << L"\n";
                return false;
            }
            if (end_index.size() != 6) {
                std::wcerr << L"end_index：html的十进制数字符个数不为6：" << MY_TOOLS::to_wstring(end_index) << L"\n";
                return false;
            }
            start_number = MY_TOOLS::string_to_value(start_index.substr(2, 3), "", &conversion_result);
            if (conversion_result) {
                end_number = MY_TOOLS::string_to_value(end_index.substr(2, 3), "", &conversion_result);
                if (conversion_result) {
                    htmlCode_to_char(static_cast<int>(start_number), static_cast<int>(end_number - start_number));
                    return true;
                }
                else {
                    //转换失败
                    std::wcerr << L"html数字转换失败，end_index：" << MY_TOOLS::to_wstring(end_index) << L'\n';
                    return false;
                }
            }
            else {
                //转换失败
                std::wcerr << L"html数字转换失败，start_index：" << MY_TOOLS::to_wstring(start_index) << L'\n';
                return false;
            }
        }
        else {
            //同一次解析遇到前后不一样的情况，视为错误；
            std::wcerr << L"同一次解析遇到前后不一样的情况，视为错误：" << MY_TOOLS::to_wstring(start_index) << L"-" << MY_TOOLS::to_wstring(end_index) << L'\n';
            return false;
        }
    }
    else if ('0' <= start_index[0] && '9' >= start_index[0]) {
        //常规数字
        if ('0' <= end_index[0] && '9' >= end_index[0]) {
            start_number = MY_TOOLS::string_to_value(start_index, "", &conversion_result);
            end_number = MY_TOOLS::string_to_value(end_index, "", &conversion_result);
            code_to_char(start_number, end_number);
        }
        else {
            //同一次解析遇到前后不一样的情况，视为错误；
            std::wcerr << L"同一次解析遇到前后不一样的情况，视为错误：" << MY_TOOLS::to_wstring(start_index) << L"-" << MY_TOOLS::to_wstring(end_index) << L'\n';
            return false;
        }
    }
    else {
        //非预期情况
        std::wcerr << L"无法识别：" << MY_TOOLS::to_wstring(start_index) << L"\n";
        return false;
    }
    return false;
}
void analyze_code_parameter(char** source_data, unsigned len, bool flag) {
    std::string parameter_values;
    if (flag) {
        for (unsigned i{ 2 }; i < len; ++i) {
            auto split_ret = MY_TOOLS::split(source_data[i], ',', std::strlen(source_data[i]));
            for (auto& v : split_ret) {
                auto hyphen_ret = MY_TOOLS::split(v, '-', v.size());
                if (hyphen_ret.size() == 1) {
                    //没有范围，单个code
                    code_to_char_check(hyphen_ret.front(), hyphen_ret.front());
                }
                else {
                    //有范围，只取第一个和最后一个
                    code_to_char_check(hyphen_ret.front(), hyphen_ret.back());
                }
            }
        }
    }
    else {
        //提示用户输入
        std::wcout << L"请输入-code的参数值：";
        std::getline(std::cin, parameter_values);
        MY_TOOLS::replace(parameter_values, 0, parameter_values.size(), " ", ",", true);
        auto split_ret = MY_TOOLS::split(parameter_values, ',', parameter_values.size());
        for (auto& v : split_ret) {
            auto hyphen_ret = MY_TOOLS::split(v, '-', v.size());
            if (hyphen_ret.size() == 1) {
                //没有范围，单个code
                code_to_char_check(hyphen_ret.front(), hyphen_ret.front());
            }
            else {
                //有范围，只取第一个和最后一个
                code_to_char_check(hyphen_ret.front(), hyphen_ret.back());
            }
        }
    }
}
void analyze_char_parameter(char** source_data, unsigned len, bool flag) {
    std::string parameter_values;
    std::wstring data;
    if (flag) {
        for (unsigned i{ 2 }; i < len; ++i) {
            parameter_values += source_data[i];
            parameter_values += ' ';
        }
        parameter_values = parameter_values.substr(0, parameter_values.size() - 1); //去掉最后一个空格
        //扩展成wstring，识别中文
         data = MY_TOOLS::string2wstring(parameter_values);
    }
    else {
        std::wcout << L"请输入字符：\n";
        std::getline(std::wcin, data);
    }
    char_to_code(data);
}
void wirte_screen(std::wstring code, wchar_t ch, bool order, unsigned with, wchar_t spacer, wchar_t ending_symbol) {
    if (order) {
        std::wcout << std::setw(with) << code << spacer << ch << ending_symbol;
    }
    else {
        std::wcout << std::setw(with) << ch << spacer << code << ending_symbol;
    }
    if (std::wcout.fail()) {
        //检查输出流是否因为特殊字符导致无法正常输出
        std::wcout.clear(); //清除错误标志
        std::wcerr << L"特殊字符无法显示！\n";
    }
}
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件