【Base64】C++ Base64编码解码

base64编码

static const std::wstring sc_Base64Chars = L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 + /";

    std::wstring Base64Encode(const std::wstring &data)
    {
        std::wstring result;
        size_t input_size  = data.size();
        int    padding     = (3 - input_size % 3) % 3;
        size_t output_size = 4 * (input_size + padding) / 3;
        result.resize(output_size);

        auto input  = data.c_str();
        auto output = &result[0];

        for (size_t i = 0, j = 0; i < input_size;)
        {
            uint32_t octet_a = i < input_size ? static_cast<unsigned char>(input[i++]) : 0;
            uint32_t octet_b = i < input_size ? static_cast<unsigned char>(input[i++]) : 0;
            uint32_t octet_c = i < input_size ? static_cast<unsigned char>(input[i++]) : 0;

            uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;

            output[j++] = sc_Base64Chars[(triple >> 3 * 6) & 0x3F];
            output[j++] = sc_Base64Chars[(triple >> 2 * 6) & 0x3F];
            output[j++] = sc_Base64Chars[(triple >> 1 * 6) & 0x3F];
            output[j++] = sc_Base64Chars[(triple >> 0 * 6) & 0x3F];
        }

        for (int i = 0; i < padding; ++i)
        {
            output[output_size - 1 - i] = '=';
        }

        return result;
    }

Base64 解码

std::wstring Base64Decode(const std::wstring &data)
    {
        std::wstring result;
        size_t input_size = data.size();
        if (input_size % 4 != 0)
        {
            return result;
        }

        auto input = data.c_str();

        std::vector<uint8_t> tmp(input_size);
        for (size_t i = 0; i < input_size; ++i)
        {
            if (isspace(input[i]) || input[i] == '=')
            {
                continue;
            }
            size_t pos = sc_Base64Chars.find(input[i]);
            if (pos == std::wstring::npos)
            {
                return result;
            }
            tmp[i] = pos;
        }

        size_t padding = 0;
        if (input[input_size - 1] == '=')
        {
            ++padding;
        }
        if (input[input_size - 2] == '=')
        {
            ++padding;
        }

        size_t output_size = 3 * (input_size / 4) - padding;
        result.resize(output_size);

        auto output = &result[0];

        for (size_t i = 0, j = 0; i < input_size;)
        {
            uint32_t sextet_a = tmp[i++];
            uint32_t sextet_b = tmp[i++];
            uint32_t sextet_c = tmp[i++];
            uint32_t sextet_d = tmp[i++];

            uint32_t triple = (sextet_a << 3 * 6) + (sextet_b << 2 * 6) + (sextet_c << 1 * 6) + (sextet_d << 0 * 6);

            output[j++] = static_cast<unsigned char>((triple >> 2 * 8) & 0xFF);
            output[j++] = static_cast<unsigned char>((triple >> 1 * 8) & 0xFF);
            output[j++] = static_cast<unsigned char>((triple >> 0 * 8) & 0xFF);
        }

        return result;
    }