UTF-8 ，GB2312，GBK字符集的base64编码解码

Pokeeeer 2015-08-10 09:38:44
win10，VS2013，C++
现在想调查UTF-8 ，GB2312，GBK三种字符集的base64编码解码，目前网上能查到的资源中只有utf-8字符集的base64编码例子，而且还不是C++的，其他两种字符集的找不到。
希望有这类资源朋友可以分享一下！谢谢了。
...全文
815 15 打赏 收藏 转发到动态 举报
写回复
用AI写文章
15 条回复
切换为时间正序
请发表友善的回复…
发表回复
欧阳春晖 2015-08-10
  • 打赏
  • 举报
 回复
引用 3 楼 zhao4zhong1 的回复:
[quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
但翻译以及调试的工作量通常占整个项目工作量的80%以上。[/quote] 恩
赵4老师 2015-08-10
  • 打赏
  • 举报
 回复
引用 2 楼 jack960330 的回复:
算法是伪代码描述的，只要存在算法，剩下的就是翻译
但翻译以及调试的工作量通常占整个项目工作量的80%以上。
欧阳春晖 2015-08-10
  • 打赏
  • 举报
 回复
算法是伪代码描述的，只要存在算法，剩下的就是翻译
赵4老师 2015-08-10
  • 打赏
  • 举报
 回复
对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A base64编解码参考下面：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BASE64_VALUE_SZ 256
int     base64_value[BASE64_VALUE_SZ];
const unsigned char alphabet[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
class Base64Utility {
public:
    Base64Utility();
    int base64_encode(char *src, int srclen, char *dst, int tail);
    int base64_decode(char *src, int srclen, char *dst);
private:
    void base_64_init(void);
};
Base64Utility::Base64Utility() {
    base_64_init();
}
void Base64Utility::base_64_init(void) {
    int i;

    for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;
    for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;
    base64_value['='] = 0;
}
int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {
    int     bits, char_count, len;
    char    *o_char, *lim, *o_lim;
    unsigned char   c;

    if ( !src || !dst) return 0;
    len = srclen;
    lim = src + len;
    o_char = dst;
    o_lim  = dst + (len*4)/3 + 1;
    char_count = 0;
    bits = 0;
    while ( (src < lim) && (o_char < o_lim)) {
        c = *(src++);
        bits += c;
        char_count++;
        if (char_count == 3) {
            *(o_char++) = alphabet[bits >> 18];
            *(o_char++) = alphabet[(bits >> 12) & 0x3f];
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            *(o_char++) = alphabet[bits & 0x3f];
            bits = 0;
            char_count = 0;
        } else {
            bits <<= 8;
        }
    }
    if (char_count != 0) {
        bits <<= 16 - (8 * char_count);
        *(o_char++) = alphabet[bits >> 18];
        *(o_char++) = alphabet[(bits >> 12) & 0x3f];
        if (char_count == 1) {
            if (tail) {
                *(o_char++) = '=';
                *(o_char++) = '=';
            }
        } else {
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            if (tail) {
                *(o_char++) = '=';
            }
        }
    }
    *(o_char) = 0;
    return strlen(dst);
}
int Base64Utility::base64_decode(char *src, int srclen, char *dst) {
    int j;
    unsigned int k;
    int c, base_result_sz;
    long val;

    if (!src || !dst) return 0;
    base_result_sz = srclen;
    val = c = 0;
    for (j = 0; *src; src++) {
        k = (int) *src % BASE64_VALUE_SZ;
        if (base64_value[k] < 0) continue;
        val <<= 6;
        val += base64_value[k];
        if (++c < 4) continue;
        dst[j++] = (char) (val >> 16);
        dst[j++] = (val >> 8) & 0xff;
        dst[j++] = val & 0xff;
        val = c = 0;
    }
    switch (c) {
        case 2://xxxxxx xx0000
            dst[j++] = (val >> 4) & 0xff;
        break;
        case 3://XXXXXX XXxxxx xxxx00
            dst[j++] = (char) (val >> 10);
            dst[j++] = (val >> 2) & 0xff;
        break;
    }
    return j;
}
Base64Utility b64u;
#define MAXLENS 1024768
#define MAXLEND 1366360
char bufd[MAXLEND];
char bufs[MAXLENS];
FILE *fs,*fd;
int fsize;
int main(int argc,char *argv[]) {
    if (argc<4) {
    USE:
        printf("%s <-e|-E|-d> srcfile desfile\n",argv[0]);
        return 1;
    }
    if (stricmp(argv[1],"-e") && stricmp(argv[1],"-d")) goto USE;
    if (0==stricmp(argv[1],"-e")) {
        fs=fopen(argv[2],"rb");
        if (NULL==fs) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufs,1,MAXLENS,fs);
        if (fsize<=0) {
            fclose(fs);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLENS==fsize) printf("Warning: Up to %d bytes.\n",MAXLENS);
        fclose(fs);
        b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));
        fd=fopen(argv[3],"w");
        if (NULL==fd) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        fprintf(fd,"%s",bufd);
        fclose(fd);
    } else {//0==stricmp(argv[1],"-d")
        fd=fopen(argv[2],"rb");
        if (NULL==fd) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufd,1,MAXLEND,fd);
        if (fsize<=0) {
            fclose(fd);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLEND==fsize) printf("Warning: Up to %d bytes.\n",MAXLEND);
        fclose(fd);
        fsize=b64u.base64_decode(bufd,fsize,bufs);
        fs=fopen(argv[3],"wb");
        if (NULL==fs) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {
            printf("Write %s error!\n",argv[3]);
            fclose(fs);
            return 5;
        }
        fclose(fs);
    }
    return 0;
}
Pokeeeer 2015-08-10
  • 打赏
  • 举报
 回复
引用 3 楼 zhao4zhong1 的回复:
[quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
但翻译以及调试的工作量通常占整个项目工作量的80%以上。[/quote]
引用 14 楼 zilaishuichina 的回复:
[quote=引用 11 楼 UAVGCS 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 8 楼 UAVGCS 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。[/quote] base64和字符集无关吧？[/quote] 我想对某字符集编解码，为什么和字符集无关呢？[/quote] lz为什么觉得对某字符集编解码，一定是和字符集有关呢？lz是基于什么原因得出的这个结论呢？ [/quote]
引用 13 楼 jack960330 的回复:
[quote=引用 10 楼 jack960330 的回复:] [quote=引用 8 楼 UAVGCS 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。[/quote] base64和字符集无关吧？[/quote] 你输入的是那个二进制是什么字符集的，base64处理的就是什么字符集的[/quote]
引用 9 楼 fefe82 的回复:
[quote=引用 5 楼 UAVGCS 的回复:] [quote=引用 1 楼 zhao4zhong1 的回复:] 对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A base64编解码参考下面：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BASE64_VALUE_SZ 256
int     base64_value[BASE64_VALUE_SZ];
const unsigned char alphabet[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
class Base64Utility {
public:
    Base64Utility();
    int base64_encode(char *src, int srclen, char *dst, int tail);
    int base64_decode(char *src, int srclen, char *dst);
private:
    void base_64_init(void);
};
Base64Utility::Base64Utility() {
    base_64_init();
}
void Base64Utility::base_64_init(void) {
    int i;

    for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;
    for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;
    base64_value['='] = 0;
}
int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {
    int     bits, char_count, len;
    char    *o_char, *lim, *o_lim;
    unsigned char   c;

    if ( !src || !dst) return 0;
    len = srclen;
    lim = src + len;
    o_char = dst;
    o_lim  = dst + (len*4)/3 + 1;
    char_count = 0;
    bits = 0;
    while ( (src < lim) && (o_char < o_lim)) {
        c = *(src++);
        bits += c;
        char_count++;
        if (char_count == 3) {
            *(o_char++) = alphabet[bits >> 18];
            *(o_char++) = alphabet[(bits >> 12) & 0x3f];
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            *(o_char++) = alphabet[bits & 0x3f];
            bits = 0;
            char_count = 0;
        } else {
            bits <<= 8;
        }
    }
    if (char_count != 0) {
        bits <<= 16 - (8 * char_count);
        *(o_char++) = alphabet[bits >> 18];
        *(o_char++) = alphabet[(bits >> 12) & 0x3f];
        if (char_count == 1) {
            if (tail) {
                *(o_char++) = '=';
                *(o_char++) = '=';
            }
        } else {
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            if (tail) {
                *(o_char++) = '=';
            }
        }
    }
    *(o_char) = 0;
    return strlen(dst);
}
int Base64Utility::base64_decode(char *src, int srclen, char *dst) {
    int j;
    unsigned int k;
    int c, base_result_sz;
    long val;

    if (!src || !dst) return 0;
    base_result_sz = srclen;
    val = c = 0;
    for (j = 0; *src; src++) {
        k = (int) *src % BASE64_VALUE_SZ;
        if (base64_value[k] < 0) continue;
        val <<= 6;
        val += base64_value[k];
        if (++c < 4) continue;
        dst[j++] = (char) (val >> 16);
        dst[j++] = (val >> 8) & 0xff;
        dst[j++] = val & 0xff;
        val = c = 0;
    }
    switch (c) {
        case 2://xxxxxx xx0000
            dst[j++] = (val >> 4) & 0xff;
        break;
        case 3://XXXXXX XXxxxx xxxx00
            dst[j++] = (char) (val >> 10);
            dst[j++] = (val >> 2) & 0xff;
        break;
    }
    return j;
}
Base64Utility b64u;
#define MAXLENS 1024768
#define MAXLEND 1366360
char bufd[MAXLEND];
char bufs[MAXLENS];
FILE *fs,*fd;
int fsize;
int main(int argc,char *argv[]) {
    if (argc<4) {
    USE:
        printf("%s <-e|-E|-d> srcfile desfile\n",argv[0]);
        return 1;
    }
    if (stricmp(argv[1],"-e") && stricmp(argv[1],"-d")) goto USE;
    if (0==stricmp(argv[1],"-e")) {
        fs=fopen(argv[2],"rb");
        if (NULL==fs) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufs,1,MAXLENS,fs);
        if (fsize<=0) {
            fclose(fs);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLENS==fsize) printf("Warning: Up to %d bytes.\n",MAXLENS);
        fclose(fs);
        b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));
        fd=fopen(argv[3],"w");
        if (NULL==fd) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        fprintf(fd,"%s",bufd);
        fclose(fd);
    } else {//0==stricmp(argv[1],"-d")
        fd=fopen(argv[2],"rb");
        if (NULL==fd) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufd,1,MAXLEND,fd);
        if (fsize<=0) {
            fclose(fd);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLEND==fsize) printf("Warning: Up to %d bytes.\n",MAXLEND);
        fclose(fd);
        fsize=b64u.base64_decode(bufd,fsize,bufs);
        fs=fopen(argv[3],"wb");
        if (NULL==fs) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {
            printf("Write %s error!\n",argv[3]);
            fclose(fs);
            return 5;
        }
        fclose(fs);
    }
    return 0;
}
这段编解码的代码我看过了，然并卵... 我需要对应那三种字符集的Base64转换！[/quote] 都是一样的。给 base64 输入的字符串是啥编码，就是啥编码的 base64 。 base64 是对二进制字节流的编码方案，base64 本身与你给它的是不是字符串以及是什么编码的字符串无关。[/quote] 感谢大家！这部分已经搞定了，之前的知识点没了解透，理解错了...BASE64编码解码的确与字符集无关，只和源的二进制有关系！
zilaishuichina 2015-08-10
  • 打赏
  • 举报
 回复
引用 11 楼 UAVGCS 的回复:
[quote=引用 10 楼 jack960330 的回复:] [quote=引用 8 楼 UAVGCS 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。[/quote] base64和字符集无关吧？[/quote] 我想对某字符集编解码，为什么和字符集无关呢？[/quote] lz为什么觉得对某字符集编解码，一定是和字符集有关呢？lz是基于什么原因得出的这个结论呢？
欧阳春晖 2015-08-10
  • 打赏
  • 举报
 回复
引用 10 楼 jack960330 的回复:
[quote=引用 8 楼 UAVGCS 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。[/quote] base64和字符集无关吧？[/quote] 你输入的是那个二进制是什么字符集的，base64处理的就是什么字符集的
Pokeeeer 2015-08-10
  • 打赏
  • 举报
 回复
引用 9 楼 fefe82 的回复:
[quote=引用 5 楼 UAVGCS 的回复:] [quote=引用 1 楼 zhao4zhong1 的回复:] 对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A base64编解码参考下面：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BASE64_VALUE_SZ 256
int     base64_value[BASE64_VALUE_SZ];
const unsigned char alphabet[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
class Base64Utility {
public:
    Base64Utility();
    int base64_encode(char *src, int srclen, char *dst, int tail);
    int base64_decode(char *src, int srclen, char *dst);
private:
    void base_64_init(void);
};
Base64Utility::Base64Utility() {
    base_64_init();
}
void Base64Utility::base_64_init(void) {
    int i;

    for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;
    for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;
    base64_value['='] = 0;
}
int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {
    int     bits, char_count, len;
    char    *o_char, *lim, *o_lim;
    unsigned char   c;

    if ( !src || !dst) return 0;
    len = srclen;
    lim = src + len;
    o_char = dst;
    o_lim  = dst + (len*4)/3 + 1;
    char_count = 0;
    bits = 0;
    while ( (src < lim) && (o_char < o_lim)) {
        c = *(src++);
        bits += c;
        char_count++;
        if (char_count == 3) {
            *(o_char++) = alphabet[bits >> 18];
            *(o_char++) = alphabet[(bits >> 12) & 0x3f];
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            *(o_char++) = alphabet[bits & 0x3f];
            bits = 0;
            char_count = 0;
        } else {
            bits <<= 8;
        }
    }
    if (char_count != 0) {
        bits <<= 16 - (8 * char_count);
        *(o_char++) = alphabet[bits >> 18];
        *(o_char++) = alphabet[(bits >> 12) & 0x3f];
        if (char_count == 1) {
            if (tail) {
                *(o_char++) = '=';
                *(o_char++) = '=';
            }
        } else {
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            if (tail) {
                *(o_char++) = '=';
            }
        }
    }
    *(o_char) = 0;
    return strlen(dst);
}
int Base64Utility::base64_decode(char *src, int srclen, char *dst) {
    int j;
    unsigned int k;
    int c, base_result_sz;
    long val;

    if (!src || !dst) return 0;
    base_result_sz = srclen;
    val = c = 0;
    for (j = 0; *src; src++) {
        k = (int) *src % BASE64_VALUE_SZ;
        if (base64_value[k] < 0) continue;
        val <<= 6;
        val += base64_value[k];
        if (++c < 4) continue;
        dst[j++] = (char) (val >> 16);
        dst[j++] = (val >> 8) & 0xff;
        dst[j++] = val & 0xff;
        val = c = 0;
    }
    switch (c) {
        case 2://xxxxxx xx0000
            dst[j++] = (val >> 4) & 0xff;
        break;
        case 3://XXXXXX XXxxxx xxxx00
            dst[j++] = (char) (val >> 10);
            dst[j++] = (val >> 2) & 0xff;
        break;
    }
    return j;
}
Base64Utility b64u;
#define MAXLENS 1024768
#define MAXLEND 1366360
char bufd[MAXLEND];
char bufs[MAXLENS];
FILE *fs,*fd;
int fsize;
int main(int argc,char *argv[]) {
    if (argc<4) {
    USE:
        printf("%s <-e|-E|-d> srcfile desfile\n",argv[0]);
        return 1;
    }
    if (stricmp(argv[1],"-e") && stricmp(argv[1],"-d")) goto USE;
    if (0==stricmp(argv[1],"-e")) {
        fs=fopen(argv[2],"rb");
        if (NULL==fs) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufs,1,MAXLENS,fs);
        if (fsize<=0) {
            fclose(fs);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLENS==fsize) printf("Warning: Up to %d bytes.\n",MAXLENS);
        fclose(fs);
        b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));
        fd=fopen(argv[3],"w");
        if (NULL==fd) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        fprintf(fd,"%s",bufd);
        fclose(fd);
    } else {//0==stricmp(argv[1],"-d")
        fd=fopen(argv[2],"rb");
        if (NULL==fd) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufd,1,MAXLEND,fd);
        if (fsize<=0) {
            fclose(fd);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLEND==fsize) printf("Warning: Up to %d bytes.\n",MAXLEND);
        fclose(fd);
        fsize=b64u.base64_decode(bufd,fsize,bufs);
        fs=fopen(argv[3],"wb");
        if (NULL==fs) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {
            printf("Write %s error!\n",argv[3]);
            fclose(fs);
            return 5;
        }
        fclose(fs);
    }
    return 0;
}
这段编解码的代码我看过了，然并卵... 我需要对应那三种字符集的Base64转换！[/quote] 都是一样的。给 base64 输入的字符串是啥编码，就是啥编码的 base64 。 base64 是对二进制字节流的编码方案，base64 本身与你给它的是不是字符串以及是什么编码的字符串无关。[/quote] 我还是没太明白，能在解释的详细一点吗？
Pokeeeer 2015-08-10
  • 打赏
  • 举报
 回复
引用 10 楼 jack960330 的回复:
[quote=引用 8 楼 UAVGCS 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。[/quote] base64和字符集无关吧？[/quote] 我想对某字符集编解码，为什么和字符集无关呢？
欧阳春晖 2015-08-10
  • 打赏
  • 举报
 回复
引用 8 楼 UAVGCS 的回复:
[quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。[/quote] base64和字符集无关吧？
fefe82 2015-08-10
  • 打赏
  • 举报
 回复
引用 5 楼 UAVGCS 的回复:
[quote=引用 1 楼 zhao4zhong1 的回复:] 对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A base64编解码参考下面：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BASE64_VALUE_SZ 256
int     base64_value[BASE64_VALUE_SZ];
const unsigned char alphabet[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
class Base64Utility {
public:
    Base64Utility();
    int base64_encode(char *src, int srclen, char *dst, int tail);
    int base64_decode(char *src, int srclen, char *dst);
private:
    void base_64_init(void);
};
Base64Utility::Base64Utility() {
    base_64_init();
}
void Base64Utility::base_64_init(void) {
    int i;

    for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;
    for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;
    base64_value['='] = 0;
}
int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {
    int     bits, char_count, len;
    char    *o_char, *lim, *o_lim;
    unsigned char   c;

    if ( !src || !dst) return 0;
    len = srclen;
    lim = src + len;
    o_char = dst;
    o_lim  = dst + (len*4)/3 + 1;
    char_count = 0;
    bits = 0;
    while ( (src < lim) && (o_char < o_lim)) {
        c = *(src++);
        bits += c;
        char_count++;
        if (char_count == 3) {
            *(o_char++) = alphabet[bits >> 18];
            *(o_char++) = alphabet[(bits >> 12) & 0x3f];
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            *(o_char++) = alphabet[bits & 0x3f];
            bits = 0;
            char_count = 0;
        } else {
            bits <<= 8;
        }
    }
    if (char_count != 0) {
        bits <<= 16 - (8 * char_count);
        *(o_char++) = alphabet[bits >> 18];
        *(o_char++) = alphabet[(bits >> 12) & 0x3f];
        if (char_count == 1) {
            if (tail) {
                *(o_char++) = '=';
                *(o_char++) = '=';
            }
        } else {
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            if (tail) {
                *(o_char++) = '=';
            }
        }
    }
    *(o_char) = 0;
    return strlen(dst);
}
int Base64Utility::base64_decode(char *src, int srclen, char *dst) {
    int j;
    unsigned int k;
    int c, base_result_sz;
    long val;

    if (!src || !dst) return 0;
    base_result_sz = srclen;
    val = c = 0;
    for (j = 0; *src; src++) {
        k = (int) *src % BASE64_VALUE_SZ;
        if (base64_value[k] < 0) continue;
        val <<= 6;
        val += base64_value[k];
        if (++c < 4) continue;
        dst[j++] = (char) (val >> 16);
        dst[j++] = (val >> 8) & 0xff;
        dst[j++] = val & 0xff;
        val = c = 0;
    }
    switch (c) {
        case 2://xxxxxx xx0000
            dst[j++] = (val >> 4) & 0xff;
        break;
        case 3://XXXXXX XXxxxx xxxx00
            dst[j++] = (char) (val >> 10);
            dst[j++] = (val >> 2) & 0xff;
        break;
    }
    return j;
}
Base64Utility b64u;
#define MAXLENS 1024768
#define MAXLEND 1366360
char bufd[MAXLEND];
char bufs[MAXLENS];
FILE *fs,*fd;
int fsize;
int main(int argc,char *argv[]) {
    if (argc<4) {
    USE:
        printf("%s <-e|-E|-d> srcfile desfile\n",argv[0]);
        return 1;
    }
    if (stricmp(argv[1],"-e") && stricmp(argv[1],"-d")) goto USE;
    if (0==stricmp(argv[1],"-e")) {
        fs=fopen(argv[2],"rb");
        if (NULL==fs) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufs,1,MAXLENS,fs);
        if (fsize<=0) {
            fclose(fs);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLENS==fsize) printf("Warning: Up to %d bytes.\n",MAXLENS);
        fclose(fs);
        b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));
        fd=fopen(argv[3],"w");
        if (NULL==fd) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        fprintf(fd,"%s",bufd);
        fclose(fd);
    } else {//0==stricmp(argv[1],"-d")
        fd=fopen(argv[2],"rb");
        if (NULL==fd) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufd,1,MAXLEND,fd);
        if (fsize<=0) {
            fclose(fd);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLEND==fsize) printf("Warning: Up to %d bytes.\n",MAXLEND);
        fclose(fd);
        fsize=b64u.base64_decode(bufd,fsize,bufs);
        fs=fopen(argv[3],"wb");
        if (NULL==fs) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {
            printf("Write %s error!\n",argv[3]);
            fclose(fs);
            return 5;
        }
        fclose(fs);
    }
    return 0;
}
这段编解码的代码我看过了，然并卵... 我需要对应那三种字符集的Base64转换！[/quote] 都是一样的。给 base64 输入的字符串是啥编码，就是啥编码的 base64 。 base64 是对二进制字节流的编码方案，base64 本身与你给它的是不是字符串以及是什么编码的字符串无关。
Pokeeeer 2015-08-10
  • 打赏
  • 举报
 回复
引用 7 楼 jack960330 的回复:
[quote=引用 6 楼 UAVGCS 的回复:] [quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？[/quote] 哦哦，只有UTF8的，另外两个字符集的没有。。。
欧阳春晖 2015-08-10
  • 打赏
  • 举报
 回复
引用 6 楼 UAVGCS 的回复:
[quote=引用 2 楼 jack960330 的回复:] 算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？[/quote] 你都有非c++的实现了，难道不能翻译？
Pokeeeer 2015-08-10
  • 打赏
  • 举报
 回复
引用 2 楼 jack960330 的回复:
算法是伪代码描述的，只要存在算法，剩下的就是翻译
没理解...能解释下这句话吗？
Pokeeeer 2015-08-10
  • 打赏
  • 举报
 回复
引用 1 楼 zhao4zhong1 的回复:
对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A base64编解码参考下面：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BASE64_VALUE_SZ 256
int     base64_value[BASE64_VALUE_SZ];
const unsigned char alphabet[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
class Base64Utility {
public:
    Base64Utility();
    int base64_encode(char *src, int srclen, char *dst, int tail);
    int base64_decode(char *src, int srclen, char *dst);
private:
    void base_64_init(void);
};
Base64Utility::Base64Utility() {
    base_64_init();
}
void Base64Utility::base_64_init(void) {
    int i;

    for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;
    for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;
    base64_value['='] = 0;
}
int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {
    int     bits, char_count, len;
    char    *o_char, *lim, *o_lim;
    unsigned char   c;

    if ( !src || !dst) return 0;
    len = srclen;
    lim = src + len;
    o_char = dst;
    o_lim  = dst + (len*4)/3 + 1;
    char_count = 0;
    bits = 0;
    while ( (src < lim) && (o_char < o_lim)) {
        c = *(src++);
        bits += c;
        char_count++;
        if (char_count == 3) {
            *(o_char++) = alphabet[bits >> 18];
            *(o_char++) = alphabet[(bits >> 12) & 0x3f];
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            *(o_char++) = alphabet[bits & 0x3f];
            bits = 0;
            char_count = 0;
        } else {
            bits <<= 8;
        }
    }
    if (char_count != 0) {
        bits <<= 16 - (8 * char_count);
        *(o_char++) = alphabet[bits >> 18];
        *(o_char++) = alphabet[(bits >> 12) & 0x3f];
        if (char_count == 1) {
            if (tail) {
                *(o_char++) = '=';
                *(o_char++) = '=';
            }
        } else {
            *(o_char++) = alphabet[(bits >> 6) & 0x3f];
            if (tail) {
                *(o_char++) = '=';
            }
        }
    }
    *(o_char) = 0;
    return strlen(dst);
}
int Base64Utility::base64_decode(char *src, int srclen, char *dst) {
    int j;
    unsigned int k;
    int c, base_result_sz;
    long val;

    if (!src || !dst) return 0;
    base_result_sz = srclen;
    val = c = 0;
    for (j = 0; *src; src++) {
        k = (int) *src % BASE64_VALUE_SZ;
        if (base64_value[k] < 0) continue;
        val <<= 6;
        val += base64_value[k];
        if (++c < 4) continue;
        dst[j++] = (char) (val >> 16);
        dst[j++] = (val >> 8) & 0xff;
        dst[j++] = val & 0xff;
        val = c = 0;
    }
    switch (c) {
        case 2://xxxxxx xx0000
            dst[j++] = (val >> 4) & 0xff;
        break;
        case 3://XXXXXX XXxxxx xxxx00
            dst[j++] = (char) (val >> 10);
            dst[j++] = (val >> 2) & 0xff;
        break;
    }
    return j;
}
Base64Utility b64u;
#define MAXLENS 1024768
#define MAXLEND 1366360
char bufd[MAXLEND];
char bufs[MAXLENS];
FILE *fs,*fd;
int fsize;
int main(int argc,char *argv[]) {
    if (argc<4) {
    USE:
        printf("%s <-e|-E|-d> srcfile desfile\n",argv[0]);
        return 1;
    }
    if (stricmp(argv[1],"-e") && stricmp(argv[1],"-d")) goto USE;
    if (0==stricmp(argv[1],"-e")) {
        fs=fopen(argv[2],"rb");
        if (NULL==fs) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufs,1,MAXLENS,fs);
        if (fsize<=0) {
            fclose(fs);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLENS==fsize) printf("Warning: Up to %d bytes.\n",MAXLENS);
        fclose(fs);
        b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));
        fd=fopen(argv[3],"w");
        if (NULL==fd) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        fprintf(fd,"%s",bufd);
        fclose(fd);
    } else {//0==stricmp(argv[1],"-d")
        fd=fopen(argv[2],"rb");
        if (NULL==fd) {
            printf("Can not open file %s!\n",argv[2]);
            return 2;
        }
        fsize=fread(bufd,1,MAXLEND,fd);
        if (fsize<=0) {
            fclose(fd);
            printf("Can not read file %s!\n",argv[2]);
            return 3;
        }
        if (MAXLEND==fsize) printf("Warning: Up to %d bytes.\n",MAXLEND);
        fclose(fd);
        fsize=b64u.base64_decode(bufd,fsize,bufs);
        fs=fopen(argv[3],"wb");
        if (NULL==fs) {
            printf("Can not create file %s!\n",argv[3]);
            return 4;
        }
        if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {
            printf("Write %s error!\n",argv[3]);
            fclose(fs);
            return 5;
        }
        fclose(fs);
    }
    return 0;
}
这段编解码的代码我看过了，然并卵... 我需要对应那三种字符集的Base64转换！
gbk-utf8-base64编解码工具
界面工具，输入原始内容，选择编码类型，进行编码和解码，字符集支持GBK,UTF-8,编码方式支持base64，运行于windows下，是开发中常用的好工具.
gbk-utf8-base64工具
实用的base64编码解码工具，支持字符集GBK,UTF8两种，支持编码和解码，下载即可使用，小巧方便，适合开发人员使用，欢迎试用.
9节课征服「字符编码」
ASCII、GB2312、GBK、GB18030Unicode、UTF-8、UTF-16、UTF-32            
WEB前端助手(FeHelper)_v2019.09.0320.crx
JSON自动美化（页面自动检测并格式化） JSON手动美化（粘贴文本、手动格式化） JSON比对工具（支持左右两个JSON片段进行键值对比较） 字符串编解码（Unicode/UTF8/Base64/MD5） 代码美化工具（HTML/CSS/JS/XML/SQL） 代码压缩工具（HTML/CSS/JS） 二维码生成器（支持当前页面、图片、链接、选中的文字生成QrCode） 二维码解码器（支持网页二维码右键解码） 简易Postman（Api接口测试，模拟HEAD/GET/POST方式） 网页滚动截屏（将当前整个网页转为图片并保存） Markdown转换（支持Markdown与HTML的互转） 页面取色工具（滑动鼠标随意取色） Js正则表达式（正则测试、常用正则列表） 时间(戳)转换（Unix戳与本地时间的互转） 图片Base64（任意图片转DataURI格式） 随机密码生成（任意字符、任意长度、随机生成） 编码规范检测（HTML/CSS/JS规范检测） 页面性能检测（页面响应时间、Header监测） 页面栅格标尺（页面栅格化、屏幕标尺） 多维小工具集（进制转换、RGB/HEX颜色转换、Crontab、还款计算器等） 网页油猴工具（网页特效、网页定制、脚本注入、自动刷新等） Ajax调试功能（需在控制台中使用） 网页编码设置（UTF-8、GBK、日文、韩文等） 我的便签笔记（便签笔记，支持导出） 人像背景移除（将人物照片中的背景移除：抠图工具）
Python编码解码---字符集/base64
1.字符集编码转换：utf-8/gbk等 编码—转换结果为二进制的字节码 str.encode('编码类型') 解码—将二进制的字节码转换为原数据 str.decode('解码类型') 注： python3中字符串默认使用utf-8字符集，若不指定编解码类型，将默认使用utf-8 2.base64编解码： python中base64模块不能直接对字符串编码，由于base64是来自于字符集转换后...
C++ 语言

64,654

社区成员

250,484

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章