特别需要注意的是,每个文件夹下有.和..两个文件夹分别代表当前目录和上级目录(根目录的..代表当前目录)…IsDot就是用来检测当前是不是.或..的函数
C++ 获取某目录下的全部文件
C++ base64编解码
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++ 四则运算
严格照搬了严蔚敏的<数据结构>
代码逻辑未作任何修改…使用正则做公式有效性判断…
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挟持,呵呵…
将某一个容器按照另一个容器的顺序排序
假设有容器A和容器B…已知A里面有m个元素,且元素无重复,B里面有n个元素,且元素全部来自于A,并且n小于等于m…
求:将B内的元素按照A里面的顺序排序…
C++ 解决Boost正则中文支持欠佳
之前,项目中需要解析TXT文本格式做字符分割,以空格和制表符作为分隔符分割字符串…但是文档中文本格式不规范,相当多的地方采取四个空格来替代制表符,导致分割出来的子串里面存在相当多的空白字符串…
C++ 泛型编程：源起、实现与意义
为什么泛型
泛型编程（Generic Programming）最初提出时的动机很简单直接：发明一种语言机制，能够帮助实现一个通用的标准容器库。所谓通用的标准容器库，就是要能够做到，比如用一个List类存放所有可能类型的对象,这样的事情；熟悉一些其它面向对象的语言的人应该知道，如Java里面这是通过在List里面存放Object引用来实现的。Java的单根继承在这里起到了关键的作用。然而单根继承对C++这样的处在语言链底层的语言却是不能承受之重。此外使用单根继承来实现通用容器也会带来效率和类型安全方面的问题，两者都与C++的理念不相吻合。
SQLITE 原子提交原理
摘要
本人正在做一个项目，在项目中定义了自己的文件格式，为了做到停电或程序崩溃不损坏这些文件原有的数据，故针对操作的原子性做一些思考，后来看到sqlite的这篇文章，与自己的实现方式作了一些对比。故顺手在研究此文章的时候将大意译成了中文。毕竟只是一时顺手之作，应该存在不少的误读与错误，请多多包涵，此文章的原始地址在http://chensheng.net/p/sqlite/auto_commit_zh_cn.html，本文可以转载，但请保留出处，以便他人能够方便找到我在修改此文可能的错误之后重新发布的版本。如果发现错误请发mail给我erehw#163.com。
最长不重复子串
问题：找到一个字符串中的一个连续子串，这个子串内不能有任何两个字符是相同的，并且这个子串是符合要求的最长的。
void lnorepstr(char* s)
{
char A[26];
int i, j;
int maxi, maxlen = 0;
int len = strlen(s);
// for(i = 0; i < 26; i++)
// A[i] = -1;
memset(A, -1, 26);
for (i = 0; i < len; i++)
{
A[s[i] - 'a'] = 1;
for(j = i+1 ; j < len; j++)
{
if(A[s[j]-'a'] == -1) //该字符没有出现
{
A[s[j]-'a'] = 1;
if(j - i> maxlen)
{
maxlen = j - i;
maxi = i;
}
}
else
break;
}
memset(A, -1, 26);
}
printf("longest no repeat string: %.*s\n", maxlen+1, &s[maxi]);
}假设字符串全部是由小写字母组成，则内层循环最多执行26次，即最长不重复子串的长度为26，此时，时间复杂度为O(26n)。
快速排序
快速排序的基本思想是：从待排序列中任取一个，作为支点。凡关键字小于支点的记录均移动至支点之前，大于支点的记录均移动至支点之后。经过一趟排序后，待排序列将分割成两个子序列，分别进行上述操作。