Base 64 Encode/Decode Class C++SourceCode-Base 64符号化/復号クラスC++ソースコード


Base 64 Encode/Decode Class C++SourceCode-Base 64符号化/復号クラスC++ソースコード
 
1、Base64.h
 
// Base64.h: interface for the CBase64 class.
//
//

#if !defined(AFX_BASE64_H__CC47C43F_E786_44DA_828F_5B9F2F1B1160__INCLUDED_)
#define AFX_BASE64_H__CC47C43F_E786_44DA_828F_5B9F2F1B1160__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CBase64  
{
public:
	CBase64();
	virtual ~CBase64();
public:

 //  ANSI     Base64   
 static CString encode(const CString in_str);
 static void encode(LPSTR pIn, DWORD dwInLen, LPSTR pOut, LPDWORD pdwOutLen);
 
 //  Base64     ANSI   
 static CString decode(const CString in_str);
 static void decode(LPSTR pIn, DWORD dwInLen, LPSTR pOut, LPDWORD pdwOutLen);

 //  ANSI      Base64    
 static BOOL encode(const CString cstrSrc, const CString cstrDes);
 static BOOL encodeMemMap(LPCTSTR fIn, LPCTSTR fOut);

 //  Base64      ANSI    
 static BOOL decode(const CString cstrSrc, const CString cstrDes);
 static BOOL decodeMemMap(LPCTSTR fIn, LPCTSTR fOut);

 static inline PSTR AllocMemBase64(DWORD dwANSILen);
 static inline PSTR AllocMemANSI(DWORD dwBase64Len);
 static inline void FreeMemBase64(PSTR pBase64);
 static inline void FreeMemANSI(PSTR pANSI);
 
protected:
 static inline DWORD CalcANSItoBase64Len(DWORD dwANSILen);
 static inline DWORD CalcBase64toANSILen(DWORD dwBase64Len, const CString strBase64End2 = "");

private:

    // encode table(   )
    const static CString _base64_encode_chars;
 
    // decode table(   )
    const static char _base64_decode_chars[128];

};

#endif // !defined(AFX_BASE64_H__CC47C43F_E786_44DA_828F_5B9F2F1B1160__INCLUDED_)


// Base64.cpp: implementation of the CBase64 class.
//
//

#include "stdafx.h"
#include "Base64.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
 
  

 

2、Base64.cpp

 

// Base64.cpp: implementation of the CBase64 class.
//
//

#include "stdafx.h"
#include "Base64.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


// Base64.cpp: implementation of the Base64 class.
//
//   :   
//
//   :Base64      
//
//     :2004-06-08
//     :2005-06-23
//
#include "Base64.h"
#include 


//
// Construction/Destruction
//

CBase64::CBase64()
{
	
}

CBase64::~CBase64()
{

}


//
//   :    DWORD CalcANSItoBase64Len()
//   :      ANSI     Base64         
//   :    dwANSILen ANSI      
//    :  DWORD Base64      
//   :    [6/23/2005]
//
inline DWORD CBase64::CalcANSItoBase64Len(DWORD dwANSILen)
{
 return (dwANSILen%3) ? (dwANSILen+3)/3*4 : dwANSILen/3*4;
}


//
//   :    DWORD CalcBase64toANSILen()
//   :      Base64     ANSI         
//   :    dwANSILen Base64      
//   strBase64End2 Base64           
//    :  DWORD ANSI      
//   :    [6/23/2005]
//
inline DWORD CBase64::CalcBase64toANSILen(DWORD dwBase64Len, const CString strBase64End2)
{
 //  '='     ,
 int count = 0;
 for (int i=0; i>2 ];
            out_str += _base64_encode_chars[ (c1&0x3)<<4 ];
            out_str += "==";
            break;
        }

        // read the second byte
        c2 = in_str[i++];
        if ( i==len )       // pad with "="
        {
            out_str += _base64_encode_chars[ c1>>2 ];
            out_str += _base64_encode_chars[ ((c1&0x3)<<4) | ((c2&0xF0)>>4) ];
            out_str += _base64_encode_chars[ (c2&0xF)<<2 ];
            out_str += "=";
            break;
        }

        // read the third byte
        c3 = in_str[i++];
        // convert into four bytes string
        out_str += _base64_encode_chars[ c1>>2 ];
        out_str += _base64_encode_chars[ ((c1&0x3)<<4) | ((c2&0xF0)>>4) ];
        out_str += _base64_encode_chars[ ((c2&0xF)<<2) | ((c3&0xC0)>>6) ];
        out_str += _base64_encode_chars[ c3&0x3F ];
    }

    return out_str;
}


//
//   :    CString decode()
//   :     Base64     ANSI   
//   :    in_str Base64   
//    :  CString ANSI   
//   :    [6/23/2005]
//
CString CBase64::decode(const CString in_str)
{
    CString out_str;
    char c1, c2, c3, c4;
    int i = 0;
    int len = in_str.GetLength();
 
    while ( i>4) );

        // read the third byte
        do {
            c3 = in_str[i++];
            if ( c3==61 )       // meet with "=", break
                return out_str;
            c3 = _base64_decode_chars[ c3 ];
        } while ( i>2) );

        // read the fourth byte
        do {
            c4 = in_str[i++];
            if ( c4==61 )       // meet with "=", break
                return out_str;
            c4 = _base64_decode_chars[ c4 ];
        } while ( i>2 ];
            pOut[n++] = _base64_encode_chars[ (c1&0x3)<<4 ];
            pOut[n++] = '=';
            pOut[n++] = '=';
           break;
        }

        // read the second byte
        c2 = pIn[i++];
        if ( i==len )       // pad with "="
        {
            pOut[n++] = _base64_encode_chars[ c1>>2 ];
            pOut[n++] = _base64_encode_chars[ ((c1&0x3)<<4) | ((c2&0xF0)>>4) ];
            pOut[n++] = _base64_encode_chars[ (c2&0xF)<<2 ];
            pOut[n++] = '=';
            break;
        }

        // read the third byte
        c3 = pIn[i++];
        // convert into four bytes string
        pOut[n++] = _base64_encode_chars[ c1>>2 ];
        pOut[n++] = _base64_encode_chars[ ((c1&0x3)<<4) | ((c2&0xF0)>>4) ];
        pOut[n++] = _base64_encode_chars[ ((c2&0xF)<<2) | ((c3&0xC0)>>6) ];
        pOut[n++] = _base64_encode_chars[ c3&0x3F ];
    }
 *pdwOutLen = n;
}


//
//   :    void decode()
//   :     Base64     ANSI   
//   :    pIn  Base64   
//   dwInLen Base64      
//   pOut  ANSI      
//   pdwOutLen ANSI      
//    :  void
//   :    [6/24/2005]
//
void CBase64::decode(LPSTR pIn, DWORD dwInLen, LPSTR pOut, LPDWORD pdwOutLen)
{
    char c1, c2, c3, c4;
    int i = 0, n = 0;
    int len = dwInLen;

    while ( i>4) );

        // read the third byte
        do {
            c3 = pIn[i++];
            if ( c3==61 )       // meet with "=", break
                goto end; //return;
            c3 = _base64_decode_chars[ c3 ];
        } while ( i>2) );

        // read the fourth byte
        do {
            c4 = pIn[i++];
            if ( c4==61 )       // meet with "=", break
                goto end; //return;
            c4 = _base64_decode_chars[ c4 ];
        } while ( i= 2)
 {
  SetFilePointer(hIn, -2, NULL, FILE_END);
  DWORD result;
  ReadFile(hIn, szBuf, 2, &result, NULL);
  dwOutLow = CalcBase64toANSILen(dwInLow, szBuf);
 }
 hInMap = CreateFileMapping(hIn, NULL, PAGE_READONLY,
  0, 0, NULL);
 pInFile = (LPSTR)MapViewOfFile(hInMap, FILE_MAP_READ, 0, 0, 0);
 
 hOut = CreateFile(fOut, GENERIC_READ|GENERIC_WRITE, 0, NULL,
  CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 hOutMap = CreateFileMapping(hOut, NULL, PAGE_READWRITE,
  0, dwOutLow, NULL);
 pOutFile = (LPSTR)MapViewOfFile(hOutMap, FILE_MAP_WRITE, 0, 0, dwOutLow);

 //  
 pIn = pInFile;
 pOut = pOutFile;
 decode(pIn, dwInLow, pOut, &dwOutLen);

 UnmapViewOfFile(pOutFile); UnmapViewOfFile(pInFile);
 CloseHandle(hOutMap); CloseHandle(hInMap);
 CloseHandle(hOut); CloseHandle(hIn);
 return TRUE;
}


//
//   :    BOOL encode()
//   :     ANSI      Base64    
//   :    cstrSrc ANSI      
//   cstrDes Base64      
//    :  BOOL TRUE(  ) FALSE(  )
//   :    [6/24/2005]
//
BOOL CBase64::encode(const CString cstrSrc, const CString cstrDes)
{
 try
 {
  CFile file(cstrSrc, CFile::modeRead);
  CFile desFile(cstrDes, CFile::modeWrite | CFile::modeCreate);

  int length = file.GetLength();
  while (length>0)
  {
   int size = 4095; //   3   ,    '='  。           
   PSTR buffer=NULL;
   buffer = new TCHAR[size];
   UINT nBytesRead = file.Read(buffer, size);

   //  Base64      
   PSTR pszBase64 = AllocMemBase64(nBytesRead);
   DWORD dwBase64 = 0;
   encode(buffer, nBytesRead, pszBase64, &dwBase64);
   desFile.Write(pszBase64, dwBase64);
   FreeMemBase64(pszBase64);
   delete[] buffer;
   
   length -= nBytesRead;
  }
 }
 catch(CFileException *e)
 {
//   MessageBox(NULL, e->ReportError(), "error", MB_OK);
  e->Delete();
  return FALSE;
 }

 return TRUE;
}


//
//   :    BOOL decode()
//   :     Base64      ANSI    
//   :    cstrSrc Base64      
//   cstrDes ANSI      
//    :  BOOL TRUE(  ) FALSE(  )
//   :    [6/24/2005]
//
BOOL CBase64::decode(const CString cstrSrc, const CString cstrDes)
{
 try
 {
  CFile file(cstrSrc, CFile::modeRead);
  CFile desFile(cstrDes, CFile::modeWrite | CFile::modeCreate);

  //   ANSI    cstrANSI
  int length = file.GetLength();
  while (length>0)
  {
   int size = 4096; //   4   
   PSTR buffer=NULL;
   buffer = new TCHAR[size];
   UINT nBytesRead = file.Read(buffer, size);

   PSTR pszANSI = AllocMemANSI(nBytesRead);
   DWORD dwANSI = 0;
   decode(buffer, nBytesRead, pszANSI, &dwANSI);
   desFile.Write(pszANSI, dwANSI);
   FreeMemANSI(pszANSI);
   delete[] buffer;

   length -= nBytesRead;
  }
 }
 catch(CFileException *e)
 {
//   MessageBox(NULL, e->ReportError(), "error", MB_OK);
  e->Delete();
  return FALSE;
 }

 return TRUE;
}


 
3、Downlaod URL
http://community.kingdee.com/images/blogs/files/8329/CSDNBlogDownload/Base64EncodeDecodeClass.rar
4、Announce
This Code is found in internet.