Base64编码及编码性能测试

原创 2013年12月03日 16:36:23

原创文章,欢迎转载。转载请注明出处:http://blog.csdn.net/jmppok/article/details/17096685


1.什么是Base64编码


Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64,所以每6位为一个单元,对应某个可打印字符。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9,这样共有62个字符,此外两个可打印符号在不同的系统中而不同。


具体可参照维基百科:维基百科 Base64


2.为什么要使用Base64编码

在计算机使用过程中,经常会遇到Binary数据,即一个数据块,我们知道其首地址和长度,通过指针即可对其进行快速访问。

但实际环境中,我们又经常需要将这个数据转换为String字符串,而在String字符串中有一个规则,遇到'\0'字符便认为字符串结束。我们不能保证Binary数据中有没有'\0'字符,所以直接将Binary数据赋值给String便可能出现问题。

而解决这一问题的办法就是使用Base64编码,上面说到Base64编码只有64个字符,'A-Z' 'a-z' '0-9' + /。没有'\0'字符,我们只要先办Binary转为Base64编码格式,即可避免出现'\0'字符,从而在赋值给String时变得可靠。

3.编码规则

二机制数据通过8位表示一个字符,Base64通过6位表示一个字符。所以将一个二进制数据转换为Base64编码,其长度要增加 (lengh*8/6)倍。

其规则如下:

1)依次从Binary数据中取出6位,转换为一个Base64字符;

2)如果最后有剩余则以0补够6位。在补位的同时,需要在Base64结尾以‘=’进行标识,一个'='表示补2个0,两个'==',表示补4个0。

需要注意的是第二条规则,由于数据本身是8的倍数,所以每次取6位,最后的余数只能是2或4。这两个则通过在Base64结尾加‘=’和'=='标识。


下面是一个Base64编码索引表和补位的说明:

Base64索引表:

Value Char   Value Char   Value Char   Value Char
0 A 16 Q 32 g 48 w
1 B 17 R 33 h 49 x
2 C 18 S 34 i 50 y
3 D 19 T 35 j 51 z
4 E 20 U 36 k 52 0
5 F 21 V 37 l 53 1
6 G 22 W 38 m 54 2
7 H 23 X 39 n 55 3
8 I 24 Y 40 o 56 4
9 J 25 Z 41 p 57 5
10 K 26 a 42 q 58 6
11 L 27 b 43 r 59 7
12 M 28 c 44 s 60 8
13 N 29 d 45 t 61 9
14 O 30 e 46 u 62 +
15 P 31 f 47 v 63 /

如果要编码的字节数不能被3整除,最后会多出1个或2个字节,那么可以使用下面的方法进行处理:先使用0字节值在末尾补足,使其能够被3整除,然后再进行base64的编码。在编码后的base64文本后加上一个或两个'='号,代表补足的字节数。也就是说,当最后剩余一个八位字节(一个byte)时,最后一个6位的base64字节块有四位是0值,最后附加上两个等号;如果最后剩余两个八位字节(2个byte)时,最后一个6位的base字节块有两位是0值,最后附加一个等号。 参考下表:

文本(1 Byte) A    
二进制位 0 1 0 0 0 0 0 1                                
二进制位(补0) 0 1 0 0 0 0 0 1 0 0 0 0                        
Base64编码 Q Q    
文本(2 Byte) B C  
二进制位 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1     x x x x x x
二进制位(补0) 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 0 0 x x x x x x
Base64编码 Q k M  



4.举例说明

1) 0 1 2编码为Base64

0 1 2 二进制表示为 0011 0000        0011  0001     0011  0010

转换为Base64为    001100          000011          000100              110010 

                           即    12                        3                   4                         50

从编码表中查找       M                          D                  E                          y

所以对应的Base64编码为 "MDEy"


2) 0123编码为Base64(需要补位)

0 1  2  3 二进制表示为 0011 0000        0011  0001     0011  0010        0011  0011

转换为Base64为    001100          000011          000100              110010   001100     110000(后面补4个0)

                           即    12                        3                   4                         50              12              48

从编码表中查找       M                          D                  E                          y                 M                w

所以对应的Base64编码为 "MDEyMw==" (由于补了4个0,因此需要加上'==')


5.C++代码


包括Base64.h 和Base64.cpp 以及一个测试程序 main.cpp

Base64.h

#ifndef BASE64_H_
#define BASE64_H_

void base64_encode(const char * pData, int len, char * pOut);

void base64_decode(const char * pData, int len, char * pOut);

int calc_base64_len(int data_len);
int calc_data_len(const char * base64, int base64_len);

#endif


Base64.cpp

#include "Base64.h"


int calc_base64_len(int data_len)
{
	int last = data_len*8%6;
	if(last == 0)
	{
		return data_len*8/6;
	}
	else
	{
		int base64_len = data_len*8/6+1;
		base64_len += (last==2?2:1);
		return base64_len;
	}
}
int calc_data_len(const char * base64, int base64_len)
{
	int dec = 0;
	while(base64[base64_len-1-dec]== '=')
	{
		dec++;
	}
	
	return ((base64_len-dec)*6)/8;
}

char _getBase64Char(char c)
{
	if(c>=0 && c<26)
	{
		return 'A'+c;
	}
	else if(c>=26 && c<52)
	{
		return 'a'+c-26;
	}
	else if(c>=52 && c<62)
	{
		return '0'+c-52;
	}
	else if(c==62)
	{
		return '+';
	}
	else if(c==63)
	{
		return '/';
	}
		
}

char _getCharOfBase64(char c)
{
	if(c>='A' && c<='Z')
	{
		return c-'A';
	}
	else if(c>='a' && c<='z')
	{
		return c-'a'+26;
	}
	else if(c>='0' && c<='9')
	{
		return c-'0'+52;
	}
	else if(c=='+')
	{
		return 62;
	}
	else if(c=='/')
	{
		return 63;
	}
}

void base64_encode(const char * pData, int len, char * pOut)
{
	int index = 0;
	while(len-index>=3)
	{
		const char * p1 = pData+index;
		const char * p2 = p1+1;
		const char * p3 = p2+1;
		
		char c1 = ((*p1) & (0b11111100)) >>2;
		char c2 = ((*p1) & (0b00000011))<<4 | ((*p2) & 0b11110000)>>4;
		char c3 = ((*p2) & (0b00001111))<<2 | ((*p3) & 0b11000000)>>6;
		char c4 = (*p3) & (0b00111111);
		
		*(pOut++)=_getBase64Char(c1);
		*(pOut++)=_getBase64Char(c2);
		*(pOut++)=_getBase64Char(c3);
		*(pOut++)=_getBase64Char(c4);

		index+=3;
	}
	
	int last = len-index;
	if(last==1)
	{
		const char * p1 = pData + index;
		char c1 = ((*p1) & (0b11111100)) >>2;
		char c2 = ((*p1) & (0b00000011))<<4;
		*(pOut++)=_getBase64Char(c1);
		*(pOut++)=_getBase64Char(c2);
		*(pOut++)='=';
		*(pOut++)='=';
	
	}
	else if(last == 2)
	{
		const char * p1 = pData+index;
		const char * p2 = p1+1;
		char c1 = ((*p1) & (0b11111100)) >>2;
		char c2 = ((*p1) & (0b00000011))<<4 | ((*p2) & 0b11110000)>>4;
		char c3 = ((*p2) & (0b00001111))<<2 ;
		
		*(pOut++)=_getBase64Char(c1);
		*(pOut++)=_getBase64Char(c2);
		*(pOut++)=_getBase64Char(c3);
		*(pOut++)='=';
		//*(pOut++)='=';
	}
		
}

void base64_decode(const char * pData, int len, char * pOut)
{
	int dec = 0;
	while(pData[len-1-dec]== '=')
	{
		dec++;
	}
	
	
	int real_len = len-dec;
	int index=0;
	while(real_len-index>=4)
	{
		const char * p1 = pData+index;
		const char * p2 = p1+1;
		const char * p3 = p2+1;
		const char * p4 = p3+1;
		
		char c1 = _getCharOfBase64(*p1);
		char c2 = _getCharOfBase64(*p2);
		char c3 = _getCharOfBase64(*p3);
		char c4 = _getCharOfBase64(*p4);
		
		*(pOut++)=(c1)<<2 | ((c2)&(0b00110000))>>4;
		*(pOut++)=((c2)&(0b00001111))<<4 | ((c3)&(0b00111100))>>2;
		*(pOut++)=((c3)&(0b00000011))<<6 | (c4)&(0b00111111);
		
		
		index+=4;
	}
	
	int last = real_len-index;
	if(last == 2)
	{
		const char * p1 = pData+index;
		const char * p2 = p1+1;
		
		char c1 = _getCharOfBase64(*p1);
		char c2 = _getCharOfBase64(*p2);
		
		*(pOut++)=(c1)<<2 | ((c2)&(0b00110000))>>4;
		
	}
	else if(last ==3)
	{
		const char * p1 = pData+index;
		const char * p2 = p1+1;
		const char * p3 = p2+1;
		
		char c1 = _getCharOfBase64(*p1);
		char c2 = _getCharOfBase64(*p2);
		char c3 = _getCharOfBase64(*p3);
		
		*(pOut++)=(c1)<<2 | ((c2)&(0b00110000))>>4;
		*(pOut++)=((c2)&(0b00001111))<<4 | ((c3)&(0b00110000))>>2;

	}
	
}


main.cpp

#include <stdio.h>
#include "time.h"
#include "Base64.h"

const char * file_in = "c:\\temp\\1.jpg";
const char * file_mid = "c:\\temp\\1.base64";
const char * file_out="c:\\temp\\11.jpg";

int main(int argc, char **argv)
{

	char * pData;
	int len;
	FILE * fp = fopen(file_in,"rb");
	if(fp)
	{
		fseek(fp,0,SEEK_END);
		len = ftell(fp);
		fseek(fp,0,SEEK_SET);
		
		pData = new char[len];
		fread(pData,1,len,fp);
		fclose(fp);
	}
	
	int base64_len = calc_base64_len(len);
	//int base64_len = len*8/6+1;
	//base64_len += (len*8%6)/2; //'='

	
	char * pOut = new char[base64_len];
	//encodeBase64(pData,len,pOut);
	base64_encode(pData,len,pOut);
	/*
	clock_t begin,end;
	begin = clock();
	int loop=0;
	while(loop<1000)
	{
	base64_encode(pData,len,pOut);
	loop++;
	}
	end = clock();
	printf("time used %d ms.\n",(end-begin));
	return 0;
	*/
	 
	//pOut[base64_len-1]='\0';
	fp = fopen(file_mid,"wb");
	if(fp)
	{
		fwrite(pOut,1,base64_len, fp);
		fclose(fp);
	}
	
	if(pData)
	{
		delete []pData;
	}
	
	if(pOut)
	{
		delete []pOut;
	}
	
	// read
	fp = fopen(file_mid,"rb");
	if(fp)
	{
		fseek(fp,0,SEEK_END);
		base64_len = ftell(fp);
		fseek(fp,0,SEEK_SET);
		
		pData = new char[base64_len];
		fread(pData,1,base64_len,fp);
		fclose(fp);
	}
	
	//int dec = 0;
	//while(pData[base64_len-1-dec]== '=')
	//{
	//	dec++;
	//}
	
	//len = ((base64_len-dec)*6)/8;
	len = calc_data_len(pData,base64_len);
	pOut = new char[len];
	//decodeBase64(pData,base64_len,pOut);
	base64_decode(pData,base64_len,pOut);
	fp = fopen(file_out,"wb");
	if(fp)
	{
		fwrite(pOut,1,len,fp);
		fclose(fp);
	}
	
	if(pData)
	{
		delete []pData;
	}
	
	if(pOut)
	{
		delete []pOut;
	}
	
	return 0;
}

main.cpp读取c:\temp\1.jpg,进行Base64编码,将编码结果写入c:\temp\1.base64, 然后再从c:\temp\1.base64中读取,解码还原,写入 c:\temp\11.jpg.


6.Base64编码性能测试

测试环境:普通PC机   i5 3470 3.2GGhz,内存4G,可用3.76  ,win7  32位

使用上述代码,编译环境为mingw。

只测试了Base64 encode的性能,encode1000次,取平均时间:

100K大小数据                               1.014ms

200K大小数据                               1.981ms

300K                                                2.917ms              

500K                                                4.961ms

1M                                                     10.624ms


总结:Base64编码耗时与数据大小成线形比例,在数据量不大时耗时很小。




7.总结与改进 

1)该测试程序为本人随手而写,还有许多改进空间;以此程序进行测试的结果,仅作参考。

2)由于时间有限,未进行Base64解码的测试。


在这篇文章中进行了改进,encode效率提高8倍左右。

http://blog.csdn.net/jmppok/article/details/17137839

const常量引用的使用方法

C++编程语言中,对于常量的引用是一个非常重要的应用技巧。在这篇文章中,我们将会为大家详细介绍一下有关C++常量引用的相关应用方法,相信大家可以从中学到很多知识。 C++单例模式基础内容详解C++...

Base64编码及编码性能测试 [改进]

原创文章,欢迎转载,转载请注明出处: 参考:Base64编码及编码性能测试 主要是针对文章中 Base64.cpp中的_getBase64Char(char c)和_getCharOfBase...
  • jmppok
  • jmppok
  • 2013年12月05日 11:00
  • 1759

java:7种Base64编码和解码功能详解和性能比较

Java 8新特性探究(十一)Base64详解 BASE64 编码是一种常用的字符编码,在很多地方都会用到。但base64不是安全领域下的加密解密算法。能起到安全作用的效果很差,而且很容...

Base64 编码和性能,第 2 部分

原文链接: https://csswizardry.com/2017/02/base64-encoding-and-performance-part-2/ 这是这篇文章的第 2 部分。阅读第 1 部分...
  • YITA90
  • YITA90
  • 2017年05月03日 20:37
  • 464

网页图片转base64编码的性能分析

拿了解的两种让网页图片得到加载的方式来说,一种是雪碧图,另外一种是转成base64编码,base64编码是今天看到url-loader特意去查看的,进而弄懂了其本质,本篇文章主要介绍base641 B...

7种Base64编码和解码功能详解和性能比较

来源:http://blog.csdn.net/u013476542/article/details/53213783 BASE64 编码是一种常用的字符编码,在很多地方都会用到。但base64...

Base64 编码和性能,第 1 部分

原文链接:https://csswizardry.com/2017/02/base64-encoding-and-performance/ 作者:Harry Roberts 来源:CSS Wizar...
  • YITA90
  • YITA90
  • 2017年03月10日 15:42
  • 136

Base64编码认识(Java 测试)

简述: Base64的一个转码的实现 原理: Base64编码方法要求把每三个8Bit的字节转换为四个6Bit的字节,其中,转换之后的这四个字节中每6个有效bit为是有效数据,空余的那两...
  • anialy
  • anialy
  • 2013年03月04日 21:06
  • 2612

c语言实现base64编码解码

  • 2015年04月20日 18:26
  • 4KB
  • 下载

Base64编码实例详解

  • 2016年06月26日 00:28
  • 32KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Base64编码及编码性能测试
举报原因:
原因补充:

(最多只允许输入30个字)