C 代码如下,小弟自己手工转换后很多错误,请大家帮帮忙,非常感谢!
//反Base64数组,可以优化,变成全局,一次生成
char ReverseBase[256];
//函数所用到的变量初始化
int Funs_Gps_Init()
{
    Base64Init();
    return 1;
}//转义函数
int Transfer7D(char *NewBuf,const char *p_OldBuf,int OldLen)
{
    unsigned char* OldBuf=(unsigned char*)p_OldBuf;
int Offset=0;
for(int i=0;i<OldLen;i++)
{
if(OldBuf[i] ==0x7d || OldBuf[i] ==0x7e || OldBuf[i] ==0x7f)
{
//需要转义
NewBuf[Offset++]=0x7D;
NewBuf[Offset++]=OldBuf[i] ^ 0x20; }else
{
NewBuf[Offset++]=OldBuf[i];
}
}
return Offset;
}//翻转义
int Restore7D(const char* pBuff,int BuffLen,char* Dest)
{
    unsigned char *Src=(unsigned char *)pBuff;
    int i=0;
    int iDest=0;
    for(;i<BuffLen;++i,++iDest)
    {
        if(*(Src+i)==0x7D)
        {
            ++i;
            *(Dest+iDest)=*(Src+i) ^ 0x20;
        }else
        {
            *(Dest+iDest)=*(Src+i);
        }
    }    return iDest;
}
//在反Base64时的数组初始化
int Base64Init()
{
    char Base[]= 
    {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', 
    'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', 
    'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', 
    'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='};    char i=0;
    for(;i<sizeof(Base)-1;++i)
    {
        ReverseBase[Base[i]]=i;
    }
    return 1;
}
//一种编码方式
int ToBase64(const char * Buf,int Len,char * Base64Buf)
{
    char Base[]= 
    {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', 
    'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', 
    'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', 
    'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='};
//求出倍数
int Multiple3 = Len/3;
int Offset=0;
char OldTemp[3];
for(int i=0;i<Multiple3;i++)
{
memcpy(OldTemp,Buf + 3*i,3);
Base64Buf[Offset++]= Base[((OldTemp[0]>>2) & 0x3F)];
Base64Buf[Offset++]= Base[(((OldTemp[0] & 0x03 )<<4) | (OldTemp[1]>>4 & 0x0F))];
Base64Buf[Offset++]= Base[(((OldTemp[1] & 0x0F)<<2 ) | (OldTemp[2]>>6 & 0x03))] ;
Base64Buf[Offset++]= Base[((OldTemp[2]) & 0x3F)];
}
if((Len%3)==0)
{
}
else if((Len % 3)==1)
{
memcpy(OldTemp,Buf + Multiple3 * 3 ,1);
//用来补
//OldTemp[1] = OldTemp[2] = '=';
Base64Buf[Offset++]= Base[((OldTemp[0]>>2) & 0x3F)];
Base64Buf[Offset++]= Base[(((OldTemp[0] & 0x03 )<<4) )];
        Base64Buf[Offset++]= '=';
        Base64Buf[Offset++]= '=';
}
else
{
memcpy(OldTemp,Buf +  Multiple3 * 3,2);
//用来补
//OldTemp[2] = '=';
Base64Buf[Offset++]= Base[((OldTemp[0]>>2) & 0x3F)];
Base64Buf[Offset++]= Base[(((OldTemp[0] & 0x03 )<<4) | (OldTemp[1]>>4 & 0x0F))];
Base64Buf[Offset++]= Base[(((OldTemp[1] & 0x0F)<<2 ) )] ;
        Base64Buf[Offset++]= '=';
}
return Offset;
}
//反Base64编码
int FromBase64(const char* Buf,int Len,char* HexBuf)
{
    if(Len % 4 !=0)
    {
        return 0;
    }    int EqualCount=0;       //数据的最后等号个数
    //最后的数据
    if(Buf[Len-1]=='=')
    {
        EqualCount++;
    }
    if(Buf[Len-2]=='=')
    {
        EqualCount++;
    }
    char tmp[4];
    int i=0;
    int offset=0;
    
    while(offset < Len)
    {
        //提取出来
        tmp[0]=ReverseBase[Buf[offset++]];
        tmp[1]=ReverseBase[Buf[offset++]];
        tmp[2]=ReverseBase[Buf[offset++]];
        tmp[3]=ReverseBase[Buf[offset++]];                //3f=00111111  0x30=00110000
        HexBuf[i++]=((tmp[0] & 0x3F )<<2) | ((tmp[1] & 0x30)>>4);
        //0f=00001111 3C=00111100
        HexBuf[i++]=((tmp[1] & 0x0F )<<4) | ((tmp[2] & 0x3C)>>2);
        //00000011   3f=00111111
        HexBuf[i++]=((tmp[2] & 0x03 )<<6) | ((tmp[3] & 0x3f)>>0);    }    //assert(i==Len/4*3);    return i-EqualCount;
}//加密
int DB44Encode(char* Buff,int Len,unsigned long Key)
{
    const unsigned long M1  =0x01000030;  
    const unsigned long IA1 =0x00000001;  
    const unsigned long IC1 =0x00000002;      //用N模伪随机序列发生器产生伪随机字节序列    
    unsigned short idx = 0;  
    if( Key == 0 ) Key = 1;  
    while( idx < Len )  
    { 
        Key = IA1 * ( Key % M1 ) + IC1;  
        Buff[idx++] ^= (unsigned char)((Key>>20)&0xFF);
    } 
    return 1;
}//加密
int DB44Encode(unsigned char* Buff,int Len,unsigned long Key)
{
    return DB44Encode((char*)Buff,Len,Key);
}
//解密
int DB44Decode(char* Buff,int Len,unsigned long Key)
{
    return DB44Encode(Buff,Len,Key);
}//解密
int DB44Decode(unsigned char* Buff,int Len,unsigned long Key)
{
    return DB44Decode((char*)Buff,Len,Key);
}const unsigned short CRC16Table[256] = {
    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
    0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
    0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
    0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
    0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
    0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
    0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
    0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
    0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
    0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
    0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
    0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
    0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
    0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
    0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
    0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
    0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
    0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
    0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
    0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
    0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
    0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
    0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
    0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
    0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
    0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
    0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};//校验,从帧头(不包含)到校验前的CRC-CNITT的校验值,高字节在前,低字节在后 
//CRC-CCITT码生成多项式为x16+x12+x5+10,简记式为:1021。
unsigned short GetDB44Parity(const char* Buff,int BuffLen)
{
    unsigned short i;
    unsigned short crc=0;
    for(i=0;i<BuffLen;i++)
    {
        crc =(crc >> 8) ^ CRC16Table[(crc ^ Buff[i]) & 0xFF];  
    }
    return(crc);}

解决方案 »

  1.   

    我以前用翻译软件将vb转化为了c#,你找找有没有类似的翻译软件!
      

  2.   

    VB转C#有在线转换的网站,C的还真没找到!
      

  3.   

    未调试,自己完善吧        //反Base64数组,可以优化,变成全局,一次生成
            char[] ReverseBase = new char[256];
            //函数所用到的变量初始化
            private int Funs_Gps_Init()
            {
                Base64Init();
                return 1;
            }        //转义函数
            private int Transfer7D(char[] NewBuf, char[] p_OldBuf, int OldLen)
            {
                char[] OldBuf = p_OldBuf;
                int Offset = 0;
                for (int i = 0; i < OldLen; i++)
                {
                    if ((byte)OldBuf[i] == 0x7d || (byte)OldBuf[i] == 0x7e || (byte)OldBuf[i] == 0x7f)
                    {
                        //需要转义
                        NewBuf[Offset++] = (char)0x7D;
                        NewBuf[Offset++] = (char)(OldBuf[i] ^ 0x20);                }
                    else
                    {
                        NewBuf[Offset++] = OldBuf[i];
                    }
                }
                return Offset;
            }
            //翻转义
            private int Restore7D(char[] pBuff, int BuffLen, char[] Dest)
            {
                char[] Src = pBuff;
                int i = 0;
                int iDest = 0;
                for (; i < BuffLen; ++i, ++iDest)
                {
                    if ((byte)Src[i] == 0x7D)
                    {
                        ++i;
                        Dest[iDest] = (char)(Src[i] ^ 0x20);
                    }
                    else
                    {
                        Dest[iDest] = Src[i];
                    }
                }            return iDest;
            }
            private int Base64Init()
            {
                char[] Base = new char[]
        {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', 
        'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', 
        'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', 
        'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='};            char i = (char)0;
                for (; i < Base.Length - 1; ++i)
                {
                    ReverseBase[Base[i]] = i;
                }
                return 1;
            }        //一种编码方式
            private int ToBase64(char[] Buf, int Len, char[] Base64Buf)
            {
                char[] Base = new char[] 
        {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', 
        'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', 
        'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', 
        'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='};
                //求出倍数
                int Multiple3 = Len / 3;
                int Offset = 0;
                char[] OldTemp = new char[3];
                for (int i = 0; i < Multiple3; i++)
                {
                    Array.Copy(Buf, i * 3, OldTemp, 0, 3);
                    OldTemp[i] = Buf[3 * i];
                    Base64Buf[Offset++] = Base[((OldTemp[0] >> 2) & 0x3F)];
                    Base64Buf[Offset++] = Base[(((OldTemp[0] & 0x03) << 4) | (OldTemp[1] >> 4 & 0x0F))];
                    Base64Buf[Offset++] = Base[(((OldTemp[1] & 0x0F) << 2) | (OldTemp[2] >> 6 & 0x03))];
                    Base64Buf[Offset++] = Base[((OldTemp[2]) & 0x3F)];
                }
                if ((Len % 3) == 0)
                {
                }
                else if ((Len % 3) == 1)
                {
                    OldTemp[0] = Buf[3 * 3];
                    //用来补
                    //OldTemp[1] = OldTemp[2] = '=';
                    Base64Buf[Offset++] = Base[((OldTemp[0] >> 2) & 0x3F)];
                    Base64Buf[Offset++] = Base[(((OldTemp[0] & 0x03) << 4))];
                    Base64Buf[Offset++] = '=';
                    Base64Buf[Offset++] = '=';
                }
                else
                {
                    Array.Copy(Buf, Multiple3 * 3, OldTemp, 0, 2);
                    //用来补
                    //OldTemp[2] = '=';
                    Base64Buf[Offset++] = Base[((OldTemp[0] >> 2) & 0x3F)];
                    Base64Buf[Offset++] = Base[(((OldTemp[0] & 0x03) << 4) | (OldTemp[1] >> 4 & 0x0F))];
                    Base64Buf[Offset++] = Base[(((OldTemp[1] & 0x0F) << 2))];
                    Base64Buf[Offset++] = '=';
                }
                return Offset;
            }        //反Base64编码
            private int FromBase64(char[] Buf, int Len, char[] HexBuf)
            {
                if (Len % 4 != 0)
                {
                    return 0;
                }            int EqualCount = 0;       //数据的最后等号个数
                //最后的数据
                if (Buf[Len - 1] == '=')
                {
                    EqualCount++;
                }
                if (Buf[Len - 2] == '=')
                {
                    EqualCount++;
                }
                char[] tmp = new char[4];
                int i = 0;
                int offset = 0;            while (offset < Len)
                {
                    //提取出来
                    tmp[0] = ReverseBase[Buf[offset++]];
                    tmp[1] = ReverseBase[Buf[offset++]];
                    tmp[2] = ReverseBase[Buf[offset++]];
                    tmp[3] = ReverseBase[Buf[offset++]];                //3f=00111111  0x30=00110000
                    HexBuf[i++] = (char)(((tmp[0] & 0x3F) << 2) | ((tmp[1] & 0x30) >> 4));
                    //0f=00001111 3C=00111100
                    HexBuf[i++] = (char)(((tmp[1] & 0x0F) << 4) | ((tmp[2] & 0x3C) >> 2));
                    //00000011   3f=00111111
                    HexBuf[i++] = (char)(((tmp[2] & 0x03) << 6) | ((tmp[3] & 0x3f) >> 0));            }            //assert(i==Len/4*3);            return i - EqualCount;
            }        //加密
            private int DB44Encode(char[] Buff, int Len, ulong Key)
            {
                ulong M1 = 0x01000030;
                ulong IA1 = 0x00000001;
                ulong IC1 = 0x00000002;            //用N模伪随机序列发生器产生伪随机字节序列    
                ushort idx = 0;
                if (Key == 0) Key = 1;
                while (idx < Len)
                {
                    Key = IA1 * (Key % M1) + IC1;
                    Buff[idx++] ^= (char)((Key >> 20) & 0xFF);
                }
                return 1;
            }
            //加密
            private int DB44Encode(byte[] Buff, int Len, ulong Key)
            {
                return DB44Encode(Buff, Len, Key);
            }
            //解密
            private int DB44Decode(char[] Buff, int Len, ulong Key)
            {
                return DB44Encode(Buff, Len, Key);
            }
            //解密
            private int DB44Decode(byte[] Buff, int Len, ulong Key)
            {
                return DB44Decode(Buff, Len, Key);
            }
            ushort[] CRC16Table = new ushort[256] {
        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
        0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
        0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
        0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
        0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
        0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
        0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
        0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
        0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
        0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
        0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
        0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
        0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
        0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
        0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
        0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
        0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
        0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
        0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
        0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
        0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
        0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
        0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
        0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
        0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
        0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
        0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
        0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
        0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
        0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
        0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
        0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
    };
            //校验,从帧头(不包含)到校验前的CRC-CNITT的校验值,高字节在前,低字节在后 
            //CRC-CCITT码生成多项式为x16+x12+x5+10,简记式为:1021。
            private ushort GetDB44Parity(char[] Buff, int BuffLen)
            {
                ushort i;
                ushort crc = 0;
                for (i = 0; i < BuffLen; i++)
                {
                    crc = (ushort)((crc >> 8) ^ CRC16Table[(crc ^ Buff[i]) & 0xFF]);
                }
                return (crc);        }
      

  4.   


            //反Base64数组,可以优化,变成全局,一次生成
            char[] ReverseBase = new char[256];        //函数所用到的变量初始化
            int Funs_Gps_Init()
            {
                Base64Init();
                return 1;
            }
            //转义函数
            int Transfer7D(char[] NewBuf, char[] p_OldBuf, int OldLen)
            {
                char[] OldBuf = p_OldBuf;
                int Offset = 0;
                for (int i = 0; i < OldLen; i++)
                {
                    if (OldBuf[i] == 0x7d || OldBuf[i] == 0x7e || OldBuf[i] == 0x7f)
                    {
                        //需要转义
                        NewBuf[Offset++] = Convert.ToChar(0x7D);
                        NewBuf[Offset++] = Convert.ToChar(OldBuf[i] ^ 0x20);                }
                    else
                    {
                        NewBuf[Offset++] = OldBuf[i];
                    }
                }
                return Offset;
            }
            //翻转义
    int Restore7D(char[] pBuff,int BuffLen,char[] Dest)
    {
        char[] Src= pBuff;
        int i=0;
        int iDest=0;
        for(;i<BuffLen;++i,++iDest)
        {
            if(Src[i]==0x7D)
            {
                ++i;
                Dest[iDest] = Convert.ToChar(Src[i] ^ 0x20);
            }else
            {
                Dest[iDest] = Convert.ToChar(Src[i]);
            }
        }    return iDest;
    }        //在反Base64时的数组初始化
            int Base64Init()
            {
                char[] Base = 
        {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', 
        'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', 
        'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', 
        'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='};
                for (int i = 0; i < Base.Count() - 1; ++i)
                {
                    ReverseBase[Base[i]] = Convert.ToChar(i);
                }
                return 1;
            }
    不知道对不……
      

  5.   

    C的char是不是应该对应C#的byte呢?
    C#里面的char貌似和和int一样大的说……