开源代码中截取的base64编码类

<script type="text/javascript"> </script> <script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"></script>

 /* Base64.h */

/** /file Base64.h
 **	/date  2004-02-13
 **	/author grymse@alhem.net
**/
/*
Copyright (C) 2004-2006  Anders Hedstrom

This library is made available under the terms of the GNU GPL.

If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about 
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#ifndef _BASE64_H
#define _BASE64_H

#ifdef _WIN32
#pragma warning(disable:4514)
#endif

#include "StdAfx.h"
#include 
#include 

/** /defgroup util Utilities */

/** Base64 encode/decode. 
	/ingroup util */
class Base64
{
public:
	static inline bool is_base64(unsigned char c) {
		return (isalnum(c) || (c == '+') || (c == '/'));};
	std::string base64_encode(unsigned char const* , unsigned int len);
	std::string base64_encode(std::string const& s);
	std::string base64_decode(unsigned char const* , unsigned int len);
	std::string base64_decode(std::string const& s);
};

#endif // _BASE64_H

  /* Base64.cpp */

#include "StdAfx.h"
#include "Base64.h"
#include <iostream>
#include <ctype.h>

static const std::string base64_chars = 
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

std::string Base64::base64_encode(const std::string &s)
{
 return base64_encode((const unsigned char *)s.c_str(), s.length());
}

std::string Base64::base64_decode(unsigned char const* encoded_string, unsigned int in_len)
{
 int i = 0;
 int j = 0;
 int in_ = 0;
 unsigned char char_array_4[4], char_array_3[3];
 std::string ret;
 
 while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
  char_array_4[i++] = encoded_string[in_]; in_++;
  if (i ==4) {
   for (i = 0; i <4; i++)
    char_array_4[i] = base64_chars.find(char_array_4[i]);
   
   char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
   char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
   char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
   
   for (i = 0; (i < 3); i++)
    ret += char_array_3[i];
   i = 0;
  }
 }
 
 if (i) {
  for (j = i; j <4; j++)
   char_array_4[j] = 0;
  
  for (j = 0; j <4; j++)
   char_array_4[j] = base64_chars.find(char_array_4[j]);
  
  char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
  char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
  char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
  
  for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
 }
 
 return ret;
}

std::string Base64::base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len)
{
 std::string ret;
 int i = 0;
 int j = 0;
 unsigned char char_array_3[3];
 unsigned char char_array_4[4];
 
 while (in_len--) {
  char_array_3[i++] = *(bytes_to_encode++);
  if (i == 3) {
   char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
   char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
   char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
   char_array_4[3] = char_array_3[2] & 0x3f;
   
   for(i = 0; (i <4) ; i++)
    ret += base64_chars[char_array_4[i]];
   i = 0;
  }
 }
 
 if (i)
 {
  for(j = i; j < 3; j++)
   char_array_3[j] = '/0';
  
  char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
  char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
  char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
  char_array_4[3] = char_array_3[2] & 0x3f;
  
  for (j = 0; (j < i + 1); j++)
   ret += base64_chars[char_array_4[j]];
  
  while((i++ < 3))
   ret += '=';
  
 }
 
 return ret;
}

std::string Base64::base64_decode(std::string const& decode_string)
{
 return base64_decode((const unsigned char *)decode_string.c_str(), decode_string.size());
/*
 int in_len = encoded_string.size();
 int i = 0;
 int j = 0;
 int in_ = 0;
 unsigned char char_array_4[4], char_array_3[3];
 std::string ret;
 
 while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
  char_array_4[i++] = encoded_string[in_]; in_++;
  if (i ==4) {
   for (i = 0; i <4; i++)
    char_array_4[i] = base64_chars.find(char_array_4[i]);
   
   char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
   char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
   char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
   
   for (i = 0; (i < 3); i++)
    ret += char_array_3[i];
   i = 0;
  }
 }
 
 if (i) {
  for (j = i; j <4; j++)
   char_array_4[j] = 0;
  
  for (j = 0; j <4; j++)
   char_array_4[j] = base64_chars.find(char_array_4[j]);
  
  char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
  char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
  char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
  
  for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
 }
 
 return ret;*/
}