static std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
static bool is_base64(unsigned char c) {
return (isalnum(c) || (c == '+') || (c == '/'));
}
std::string base64_encode(const unsigned char* bytes_to_encode,unsigned int in_len);
int base64_decode(std::string const& encoded_string,unsigned char* pObject);
std::string base64_encode(const unsigned char* 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;
}
int base64_decode(std::string const& encoded_string,unsigned char* pObject)
{
int in_len = encoded_string.size();
int i = 0;
int j = 0;
int in_ = 0;
int iNum = 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];
iNum++;
}
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];
iNum++;
}
}
memcpy(pObject,ret.c_str(),iNum);
return iNum;
}C++ base64编解码
C++ 四则运算
严格照搬了严蔚敏的<数据结构>
代码逻辑未作任何修改…使用正则做公式有效性判断…
CParse::CParse()
{
/*********************************************************************/
// 符号定义
/*********************************************************************/
m_vecSign.push_back(std::make_pair(_T("("), 0));
m_vecSign.push_back(std::make_pair(_T(")"), 1));
m_vecSign.push_back(std::make_pair(_T("*"), 2));
m_vecSign.push_back(std::make_pair(_T("/"), 2));
m_vecSign.push_back(std::make_pair(_T("+"), 3));
m_vecSign.push_back(std::make_pair(_T("-"), 3));
m_vecSign.push_back(std::make_pair(_T("#"), 4));
/*********************************************************************/
// 符号优先级定义
// -1 < // 0 = // 1 >
// 2 error
/*********************************************************************/
m_vecPriority.resize(5);
m_vecPriority[0].resize(5);
m_vecPriority[0][0] = -1;
m_vecPriority[0][1] = 0;
m_vecPriority[0][2] = -1;
m_vecPriority[0][3] = -1;
m_vecPriority[0][4] = 2;
m_vecPriority[1].resize(5);
m_vecPriority[1][0] = 2;
m_vecPriority[1][1] = 1;
m_vecPriority[1][2] = 1;
m_vecPriority[1][3] = 1;
m_vecPriority[1][4] = 1;
m_vecPriority[2].resize(5);
m_vecPriority[2][0] = -1;
m_vecPriority[2][1] = 1;
m_vecPriority[2][2] = 1;
m_vecPriority[2][3] = 1;
m_vecPriority[2][4] = 1;
m_vecPriority[3].resize(5);
m_vecPriority[3][0] = -1;
m_vecPriority[3][1] = 1;
m_vecPriority[3][2] = -1;
m_vecPriority[3][3] = 1;
m_vecPriority[3][4] = 1;
m_vecPriority[4].resize(5);
m_vecPriority[4][0] = -1;
m_vecPriority[4][1] = 2;
m_vecPriority[4][2] = -1;
m_vecPriority[4][3] = -1;
m_vecPriority[4][4] = 0;
}
CParse::~CParse()
{
}
BOOL CParse::ParseString( const CString &strOld, const std::map &data, double &fResultValue )
{
// 此处为了性能不做有效性判断
CString strNew = _T("");
strNew.Format(_T("#%s#"), strOld);
/*********************************************************************/
// 解析堆栈
/*********************************************************************/
std::stack OPTR; // 运算符栈
std::stack OPND; // 操作数栈
/*********************************************************************/
// 分割
/*********************************************************************/
int nFind = -1;
while (0 < strNew.GetLength()) {
// 找从解析起始位置开始,最近的操作符
pair_SIGN pairSign;
nFind = strNew.GetLength();
BOOST_FOREACH(pair_SIGN tmp, m_vecSign)
{
int nTmp = strNew.Find(tmp.first);
if(-1 == nTmp) continue;
if(nFind > nTmp)
{
pairSign = tmp;
nFind = nTmp;
}
}
// 操作数进栈
CString strOperand = strNew.Left(nFind);
if(!strOperand.IsEmpty())
{
double fValue = atof(strOperand.Trim());
OPND.push(fValue);
}
strNew = strNew.Right(strNew.GetLength() - strOperand.GetLength());
if(0 < strNew.GetLength()) {
// 操作符判断
label:
if(OPTR.empty())
{
// 如果操作符栈为空,则直接入栈
OPTR.push(pairSign);
}
else
{
ASSERT(OPTR.size() > 0);
if(OPTR.size() == 0) return FALSE;
// 不为空,则判断当前取到的操作符与栈顶的操作符的优先级
switch(m_vecPriority[OPTR.top().second][pairSign.second])
{
case -1 :
{
// 栈顶元素优先级比较低
// 继续压栈
OPTR.push(pairSign);
break;
}
case 0 :
{
// 碰到匹配的括号或者字符串首尾相遇
OPTR.pop();
break;
}
case 1 :
{
ASSERT(OPND.size() > 1);
if(OPND.size() < 2) return FALSE;
// 栈顶操作符优先级高于当前获取的操作符
// 进行栈顶元素的计算
double fLeft, fRight;
fRight = OPND.top();
OPND.pop();
fLeft = OPND.top();
OPND.pop();
double fValue = 0.0f;
if(!Calc(fLeft, fRight, OPTR.top().first, fValue)) return FALSE;
OPND.push(fValue);
OPTR.pop();
goto label;
}
case 2 :
default:
{
ASSERT(FALSE);
break;
}
}
}
}
strNew = strNew.Right(strNew.GetLength() - pairSign.first.GetLength());
}
if(0 == OPTR.size() && 1 == OPND.size())
{
return TRUE;
}
return FALSE;
}
BOOL CParse::Calc( double fLeft, double fRight, CString strSign, double &fValue )
{
if(0 == strSign.CompareNoCase(_T("+")))
{
fValue = fLeft + fRight;
}
else if(0 == strSign.CompareNoCase(_T("-")))
{
fValue = fLeft - fRight;
}
else if(0 == strSign.CompareNoCase(_T("*")))
{
fValue = fLeft * fRight;
}
else if(0 == strSign.CompareNoCase(_T("/")))
{
fValue = fLeft / fRight;
}
else
{
return FALSE;
}
return TRUE;
}
BOOL CParse::IsValidID( const CString &strOld )
{
CString sCheck = _T("([+-*/]{2,})|([+-*/]\))|(^[+-*/])|([+-*/]$)");
CRegexpT regexp(sCheck);
MatchResult result = regexp.MatchExact(strOld);
if(result.IsMatched()) return FALSE;
return TRUE;
}使用正则做公式有效性判断…
DNS
最近百度老打不开…不知道是不是武汉电信的DNS不好使了,我把DNS换成谷歌的DNS就开得蛮好…
暴怒了…电信的垃圾DNS呀!!!于是果断换成谷歌DNS…顺便也可以防止电信的DNS挟持,呵呵…