字符串类型转换

于 2025-02-10 17:17:59 发布
阅读量387 收藏 2
点赞数 1
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ray_kong/article/details/145519445
版权

实现可选择的字符类型转换，包含二进制、八进制、十进制、十六进制、URL、Base64编码等。

问题

输入：转换类型和待转换数据

输出：目的类型

例：

输入：二进制转十六进制、01010101

输出：0x55

代码

头文件 

#include <iostream>
#include <string>
#include <vector>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>

方法 

void BinaryStringToOctal(const std::string& binaryString) {
    int num = 0;
    for (char c : binaryString) {
        num <<= 1;
        if (c == '1') {
            num |= 1;
        }
    }

    std::string octalString;
    int groupCount = 0;
    int groupValue = 0;
    for (int i = sizeof(int) * 8 - 1; i >= 0; i--) {
        groupValue <<= 1;
        if ((num >> i) & 1) {
            groupValue |= 1;
        }
        groupCount++;
        if (groupCount == 3 || i == 0) {
            octalString = std::to_string(groupValue) + octalString;
            groupValue = 0;
            groupCount = 0;
        }
    }

    std::cout << "八进制: " << octalString << std::endl;
}


void BinaryStringToHex(const std::string& binaryString) {
    int num = 0;
    for (char c : binaryString) {
        num <<= 1;
        if (c == '1') {
            num |= 1;
        }
    }

    std::string hexString;
    int groupCount = 0;
    int groupValue = 0;
    for (int i = sizeof(int) * 8 - 1; i >= 0; i--) {
        groupValue <<= 1;
        if ((num >> i) & 1) {
            groupValue |= 1;
        }
        groupCount++;
        if (groupCount == 4 || i == 0) {
            if (groupValue < 10) {
                hexString = static_cast<char>(groupValue + '0') + hexString;
            } else {
                hexString = static_cast<char>(groupValue - 10 + 'A') + hexString;
            }
            groupValue = 0;
            groupCount = 0;
        }
    }

    std::cout << "十六进制: " << hexString << std::endl;
}


void BinaryStringToDecimal(const std::string& binaryString) {
    int decimalNumber = 0;
    for (char c : binaryString) {
        decimalNumber <<= 1;
        if (c == '1') {
            decimalNumber |= 1;
        }
    }
    std::cout << "十进制: " << decimalNumber << std::endl;
}


// 将字符串形式的二进制数据转换为 Base64 编码
std::string BinaryStringToBase64_openSSL(const std::string& binaryString) {
    // 创建一个 Base64 编码的 BIO 对象
    BIO* b64 = BIO_new(BIO_f_base64());
    // 设置不添加换行符的标志，使编码结果更紧凑
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

    // 创建一个内存 BIO 对象，用于存储编码后的结果
    BIO* mem = BIO_new(BIO_s_mem());
    // 将内存 BIO 对象推到 Base64 BIO 对象之上，形成 BIO 链
    BIO_push(b64, mem);

    // 将字符串形式的二进制数据转换为无符号字符数组并写入 BIO 进行编码
    BIO_write(b64, binaryString.c_str(), binaryString.size());
    // 刷新 BIO 缓冲区，确保数据完全处理
    BIO_flush(b64);

    char* encodedData;
    long len = BIO_get_mem_data(mem, &encodedData);

    // 构造 Base64 编码的字符串
    std::string base64Encoded(encodedData, len);

    // 释放 BIO 对象
    BIO_free_all(b64);

    return base64Encoded;
}


// 将二进制字符串转换为 Base64 编码的函数
std::string BinaryToBase64(const std::string& binaryString) {
    // Base64 编码使用的字符表
    static const char* base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    std::string result;  // 存储编码结果
    int i = 0;  // 遍历二进制字符串的索引
    int paddingCount = 0;  // 填充字符的数量

    while (i < binaryString.size()) {
        // 取出 3 个字节
        int chunk = 0;
        int bytesRead = 0;
        for (; bytesRead < 3 && i < binaryString.size(); bytesRead++, i++) {
            chunk <<= 8;  // 左移 8 位
            chunk |= static_cast<unsigned char>(binaryString[i]);  // 合并当前字节
        }

        // 根据读取的字节数进行编码
        switch (bytesRead) {
            case 3:
                result += base64Chars[(chunk >> 18) & 0x3F];  // 取高 6 位编码
                result += base64Chars[(chunk >> 12) & 0x3F];
                result += base64Chars[(chunk >> 6) & 0x3F];
                result += base64Chars[chunk & 0x3F];
                break;
            case 2:
                result += base64Chars[(chunk >> 18) & 0x3F];
                result += base64Chars[(chunk >> 12) & 0x3F];
                result += base64Chars[(chunk >> 6) & 0x3F];
                result += '=';  // 填充一个 '='
                paddingCount++;
                break;
            case 1:
                result += base64Chars[(chunk >> 18) & 0x3F];
                result += base64Chars[(chunk >> 12) & 0x3F];
                result += '=';
                result += '=';  // 填充两个 '='
                paddingCount += 2;
                break;
        }
    }

    // 去除多余的 '=' 填充
    result = result.substr(0, result.size() - paddingCount);

    return result;
}


void OctalStringToBinary(const std::string& octalString) {
    std::string binaryString;
    for (char c : octalString) {
        int num = c - '0';
        for (int i = 2; i >= 0; i--) {
            binaryString += ((num >> i) & 1) + '0';
        }
    }
    std::cout << "二进制: " << binaryString << std::endl;
}


void OctalStringToHex(const std::string& octalString) {
    int num = 0;
    for (char c : octalString) {
        num <<= 3;
        if (c >= '0' && c <= '7') {
            num |= (c - '0');
        }
    }

    std::string hexString;
    int groupCount = 0;
    int groupValue = 0;
    for (int i = sizeof(int) * 8 - 1; i >= 0; i--) {
        groupValue <<= 1;
        if ((num >> i) & 1) {
            groupValue |= 1;
        }
        groupCount++;
        if (groupCount == 4 || i == 0) {
            if (groupValue < 10) {
                hexString = static_cast<char>(groupValue + '0') + hexString;
            } else {
                hexString = static_cast<char>(groupValue - 10 + 'A') + hexString;
            }
            groupValue = 0;
            groupCount = 0;
        }
    }

    std::cout << "十六进制: " << hexString << std::endl;
}


void OctalStringToDecimal(const std::string& octalString) {
    int decimalNumber = 0;
    for (char c : octalString) {
        decimalNumber <<= 3;
        if (c >= '0' && c <= '7') {
            decimalNumber |= (c - '0');
        }
    }
    std::cout << "十进制: " << decimalNumber << std::endl;
}


void DecimalStringToBinary(const std::string& decimalString) {
    int decimalNumber = 0;
    for (char c : decimalString) {
        if (c >= '0' && c <= '9') {
            decimalNumber = decimalNumber * 10 + (c - '0');
        }
    }

    std::string binaryString;
    int num = decimalNumber;
    while (num) {
        binaryString = (char)('0' + (num & 1)) + binaryString;
        num >>= 1;
    }

    std::cout << "二进制: " << binaryString << std::endl;
}


void DecimalStringToOctal(const std::string& decimalString) {
    int decimalNumber = 0;
    for (char c : decimalString) {
        if (c >= '0' && c <= '9') {
            decimalNumber = decimalNumber * 10 + (c - '0');
        }
    }

    std::string octalString;
    int num = decimalNumber;
    while (num) {
        octalString = (char)('0' + (num & 7)) + octalString;
        num >>= 3;
    }

    std::cout << "八进制: " << octalString << std::endl;
}


// 将十进制字符串转换为十六进制的函数
void DecimalStringToHex(const std::string& decimalString) {
    int decimalNumber = 0;  // 用于存储转换后的十进制整数

    // 将输入的十进制字符串转换为整数
    for (char c : decimalString) {
        if (c >= '0' && c <= '9') {
            decimalNumber = decimalNumber * 10 + (c - '0');
        }
    }

    std::string hexString;  // 用于存储转换后的十六进制字符串

    int num = decimalNumber;  // 临时变量，用于位操作

    // 执行位操作并转换为十六进制
    while (num) {
        int remainder = num & 15;  // 获取最低 4 位
        if (remainder < 10) {
            hexString = (char)('0' + remainder) + hexString;  // 转换为数字字符添加到结果字符串
        } else {
            hexString = (char)('A' + remainder - 10) + hexString;  // 转换为字母字符添加到结果字符串
        }
        num >>= 4;  // 右移 4 位，准备处理下一组 4 位
    }

    std::cout << "十六进制: " << hexString << std::endl;  // 输出结果
}


// 将十六进制字符串转换为二进制字符串的函数
void HexStringToBinary(const std::string& hexString) {
    std::string binaryString;  // 用于存储转换后的二进制字符串

    for (char c : hexString) {  // 遍历十六进制字符串的每个字符
        int num;  // 用于临时存储转换后的数值

        if (c >= '0' && c <= '9') {  // 如果是数字 0 - 9
            num = c - '0';  // 转换为对应的数值
        } else if (c >= 'A' && c <= 'F') {  // 如果是大写字母 A - F
            num = c - 'A' + 10;  // 转换为对应的数值 10 - 15
        } else if (c >= 'a' && c <= 'f') {  // 如果是小写字母 a - f
            num = c - 'a' + 10;  // 转换为对应的数值 10 - 15
        } else {
            std::cout << "输入的十六进制字符串不合法" << std::endl;  // 处理非法字符
            return;
        }

        for (int i = 3; i >= 0; i--) {  // 将十六进制的一位转换为 4 位二进制
            binaryString += ((num >> i) & 1) + '0';  // 通过位操作获取每一位并添加到结果字符串
        }
    }

    std::cout << "二进制: " << binaryString << std::endl;  // 输出转换后的二进制字符串
}


// 将十六进制字符串转换为八进制字符串的函数
void HexStringToOctal(const std::string& hexString) {
    int num = 0;  // 用于临时存储转换后的数值

    for (char c : hexString) {  // 遍历十六进制字符串的每个字符
        int digitValue;  // 用于存储当前字符对应的数值

        if (c >= '0' && c <= '9') {  // 如果是数字 0 - 9
            digitValue = c - '0';
        } else if (c >= 'A' && c <= 'F') {  // 如果是大写字母 A - F
            digitValue = c - 'A' + 10;
        } else if (c >= 'a' && c <= 'f') {  // 如果是小写字母 a - f
            digitValue = c - 'a' + 10;
        } else {
            std::cout << "输入的十六进制字符串不合法" << std::endl;  // 处理非法字符
            return;
        }

        num = (num << 4) | digitValue;  // 将当前十六进制位的值合并到 num 中
    }

    std::string octalString;  // 用于存储转换后的八进制字符串

    while (num) {  // 将合并后的数值转换为八进制字符串
        octalString = std::to_string(num % 8) + octalString;  // 获取八进制位并添加到字符串
        num /= 8;  // 除以 8 进行下一位的计算
    }

    std::cout << "八进制: " << octalString << std::endl;  // 输出八进制字符串
}


// 十六进制字符串转换为十进制的函数
void HexStringToDecimal(const std::string& hexString) {
    int decimalNumber = 0;  // 用于存储最终的十进制结果

    for (char c : hexString) {  // 遍历十六进制字符串的每个字符
        int digitValue;  // 存储当前字符对应的数值

        if (c >= '0' && c <= '9') {  // 如果是数字 0 - 9
            digitValue = c - '0';
        } else if (c >= 'A' && c <= 'F') {  // 如果是大写字母 A - F
            digitValue = c - 'A' + 10;
        } else if (c >= 'a' && c <= 'f') {  // 如果是小写字母 a - f
            digitValue = c - 'a' + 10;
        } else {
            std::cout << "输入的十六进制字符串不合法" << std::endl;  // 处理非法字符
            return;
        }

        decimalNumber = (decimalNumber << 4) | digitValue;  // 通过位操作合并当前数值
    }

    std::cout << "十进制: " << decimalNumber << std::endl;  // 输出十进制结果
}


// 将 Base64 编码转换为二进制的函数
std::string Base64ToBinary(const std::string& base64) {
    // 创建一个 Base64 解码的 BIO 对象
    BIO* b64 = BIO_new(BIO_f_base64());
    // 设置不添加换行符的标志
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

    // 创建一个内存 BIO 对象，并将输入的 Base64 字符串与之关联
    BIO* mem = BIO_new_mem_buf(const_cast<char*>(base64.c_str()), base64.size());
    // 将内存 BIO 对象推到 Base64 解码 BIO 对象之上
    BIO_push(b64, mem);

    std::vector<unsigned char> binary;
    // 预先分配一个可能足够大的空间来存储解码后的二进制数据
    // 如果解码后的数据是 ASCII 或 UTF-8 编码的文本，直接输出时会显示为可读的字符串
    binary.resize(base64.size());

    // 读取解码后的数据，并获取读取的长度
    int len = BIO_read(b64, binary.data(), binary.size());
    // 调整二进制数据的大小为实际读取的长度
    binary.resize(len);

    // 释放 BIO 对象
    BIO_free_all(b64);

    // 将二进制数据转换为字符串并返回
    return std::string(binary.begin(), binary.end());
}


// 将 URL 转换为 Base64 编码的函数
std::string UrlToBase64(const std::string& url) {
    // 创建一个用于 Base64 编码的 BIO 对象
    BIO* b64 = BIO_new(BIO_f_base64());
    // 设置不添加换行符的标志
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

    // 创建一个内存 BIO 对象
    BIO* mem = BIO_new(BIO_s_mem());
    // 将内存 BIO 对象推到 Base64 BIO 对象之上
    BIO_push(b64, mem);

    // 将 URL 数据写入 Base64 BIO 对象进行编码
    BIO_write(b64, url.c_str(), url.size());
    // 刷新 BIO 缓冲区
    BIO_flush(b64);

    // 获取内存 BIO 中的编码后的数据和长度
    char* encodedData;
    long len = BIO_get_mem_data(mem, &encodedData);

    // 构造 Base64 编码后的字符串
    std::string base64Encoded(encodedData, len);

    // 释放 BIO 对象
    BIO_free_all(b64);

    return base64Encoded;
}

// 从 Base64 编码还原为 URL 的函数
std::string Base64ToUrl(const std::string& base64Encoded) {
    // 创建一个用于 Base64 解码的 BIO 对象
    BIO* b64 = BIO_new(BIO_f_base64());
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

    // 创建一个内存 BIO 对象，并关联输入的 Base64 编码数据
    BIO* mem = BIO_new_mem_buf(const_cast<char*>(base64Encoded.c_str()), base64Encoded.size());
    BIO_push(b64, mem);

    std::vector<unsigned char> urlData;
    // 预先分配一个可能足够大的空间来存储解码后的数据
    urlData.resize(base64Encoded.size());

    // 读取解码后的数据，并获取读取的长度
    int len = BIO_read(b64, urlData.data(), urlData.size());
    // 调整向量的大小为实际读取的长度
    urlData.resize(len);

    // 释放 BIO 对象
    BIO_free_all(b64);

    // 将解码后的二进制数据转换为字符串并返回
    return std::string(urlData.begin(), urlData.end());
}

主函数

int main(int argc, char* argv[]) {
    if (argc < 3) {
        std::cerr << "Usage: " << argv[0] << " <function_name> <input>" << std::endl;
        std::cerr << "Available functions: BinaryStringToOctal, BinaryStringToHex, BinaryStringToDecimal, BinaryStringToBase64_openSSL, BinaryToBase64, OctalStringToBinary, OctalStringToHex, OctalStringToDecimal, DecimalStringToBinary, DecimalStringToOctal, DecimalStringToHex, HexStringToBinary, HexStringToOctal, HexStringToDecimal, Base64ToBinary, UrlToBase64, Base64ToUrl" << std::endl;
        return 1;
    }

    std::string functionName = argv[1];
    std::string input = argv[2];

    if (functionName == "BinaryStringToOctal") {
        BinaryStringToOctal(input);
    } else if (functionName == "BinaryStringToHex") {
        BinaryStringToHex(input);
    } else if (functionName == "BinaryStringToDecimal") {
        BinaryStringToDecimal(input);
    } else if (functionName == "BinaryStringToBase64_openSSL") {
        std::cout << BinaryStringToBase64_openSSL(input) << std::endl;
    } else if (functionName == "BinaryToBase64") {
        std::cout << BinaryToBase64(input) << std::endl;
    } else if (functionName == "OctalStringToBinary") {
        OctalStringToBinary(input);
    } else if (functionName == "OctalStringToHex") {
        OctalStringToHex(input);
    } else if (functionName == "OctalStringToDecimal") {
        OctalStringToDecimal(input);
    } else if (functionName == "DecimalStringToBinary") {
        DecimalStringToBinary(input);
    } else if (functionName == "DecimalStringToOctal") {
        DecimalStringToOctal(input);
    } else if (functionName == "DecimalStringToHex") {
        DecimalStringToHex(input);
    } else if (functionName == "HexStringToBinary") {
        HexStringToBinary(input);
    } else if (functionName == "HexStringToOctal") {
        HexStringToOctal(input);
    } else if (functionName == "HexStringToDecimal") {
        HexStringToDecimal(input);
    } else if (functionName == "Base64ToBinary") {
        std::cout << Base64ToBinary(input) << std::endl;
    } else if (functionName == "UrlToBase64") {
        std::cout << UrlToBase64(input) << std::endl;
    } else if (functionName == "Base64ToUrl") {
        std::cout << Base64ToUrl(input) << std::endl;
    } else {
        std::cerr << "Invalid function name: " << functionName << std::endl;
        return 1;
    }

    return 0;
}

运行

安装openssl开发包

sudo apt-get update
sudo apt-get install libssl-dev

如果sudo apt-get update失败，检查cat /etc/apt/sources.list软件源。

更新IncludePath

打开你的C++项目，按下 Ctrl + Shift + P 打开命令面板，然后输入并选择 C/C++: Edit Configurations (UI)。

在打开的设置界面中，找到 Include Path 部分，添加OpenSSL的头文件路径。

通常情况下，OpenSSL的头文件路径是 /usr/include/openssl，所以添加 /usr/include 到 Include Path 中。

打开 c_cpp_properties.json 文件，确保IncludePath中存在openSSL的头文件路径

 

编译

g++ code_conversion.cpp -o conversion -lssl -lcrypto

编译时需要连接两个库文件

测试

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值