近来遇到了一些常见的概念，尤其是网络编程方面的概念，如：阻塞、非阻塞、异步I/O等等，对于这些概念自己也没有太清晰的认识，只是很模糊的概念，说了解吧也了解，但是要让自己准确的描述概念方面的具体细节，却说的不那么准确，这也是自己在这几个方面也没有细细考究过的原因吧。经过看了些这几个概念的资料，发现同步、异步、阻塞、非阻塞的概念其实也并不难以理解，在此写下此文，欢迎拍砖，希望多多交流。
同步与异步、阻塞与非阻塞
闲话操作系统
关于操作系统的定义，我没有找到一个权威的解释，基本上可以说，它是一个程序，一个介于计算机硬件和计算机用户/开发者之间的程序，用户通过它来操作计算机，开发者用它提供的接口来编写程序。操作系统大概可算是最重要（也可算是最复杂）的程序，基本上，它决定了我们能用电脑干什么和怎样用电脑，软件当然是千变万化，不断发展，但无论是在那一种操作系统下跑的软件，必然受限于操作系统所提供的功能，换句话说，它只能在操作系统划下的圈子里翻筋斗。
字体平滑，反锯齿，和次像素渲染
作者：Joel Spolsky
译者：阮一峰
原文网址：http://www.joelonsoftware.com/items/2007/06/12.html
苹果公司和微软公司，对于如何在电脑屏幕上显示字体，总是有不同看法。目前，这两家公司都使用次像素渲染（subpixel rendering）技术，使得字体在低分辨率的屏幕上，也能显得很清晰。这两家公司的根本不同之处在于指导思想。
用两个栈实现一个队列
这个题其实以前我去面华为的时候被考过…前几天在网上无意间看到,勾起了回忆…
题目
用C++描述，题目大致是这样的：
已知下面Stack类及其3个方法Push、Pop和 Count，请用2个Stack实现Queue类的入队(Enqueue)出队(Dequeue)方法。
C++ 向数据库写入空值
之前一直在搞数据相关滴事情…然后碰到这么个问题,要向Access数据库的数据字段写入空值…
要是字符型字段还好说一点咯,写个空字符串就好了…
这个数字型,想想的话怎么着也要给个数字啊…
C++ access数据库中字段信息获取
void CDataControl::GetFieldNameCn(const CString& sTableName,CADORecordset* pAdoAccess,const CString& sNameEn, CString& sNameCn)
{
SAFEARRAY FAR* psa = NULL;
SAFEARRAYBOUND rgsabound;
_variant_t var;
_variant_t Array;
rgsabound.lLbound = 0;
rgsabound.cElements = 4;
psa = SafeArrayCreate(VT_VARIANT, 1, &rgsabound);
var.vt = VT_EMPTY;
long ix;
ix = 0;
SafeArrayPutElement(psa, &ix, &var);
ix= 1;
SafeArrayPutElement(psa, &ix, &var);
ix = 2;
var.vt = VT_BSTR;
var.bstrVal =sTableName.AllocSysString(); //表名 sTableName
SafeArrayPutElement(psa, &ix, &var);
var.vt = VT_BSTR;
ix = 3;
var.bstrVal =sNameEn.AllocSysString();//字段名
SafeArrayPutElement(psa, &ix, &var);
Array.vt = VT_ARRAY|VT_VARIANT;
Array.parray = psa;
pAdoAccess->m_pRecordset = pAdoAccess->GetActiveConnection()->OpenSchema(adSchemaColumns,&Array);
Field *fd = pAdoAccess->m_pRecordset->Fields->GetItem("DESCRIPTION");
if (fd->GetValue().vt != VT_NULL)
{
_bstr_t column_discription = fd->Value;
CString sNote;
sNote.Format(_T("%s"), (LPCTSTR)column_discription);
sNameCn = (LPCTSTR)column_discription;
}
else
{
sNameCn = sNameEn;
}
}
BOOL CDataControl::GetFileNULL(const CString& sTableName,const CString& sFileNameEN,CString& sFileNameCN,CADORecordset* pAdoAccess,BOOL& ISNullSet, int& OrdinalPostion)
{
SAFEARRAY FAR* psa = NULL;
SAFEARRAYBOUND rgsabound;
_variant_t var;
_variant_t Array;
rgsabound.lLbound = 0;
rgsabound.cElements = 4;
psa = SafeArrayCreate(VT_VARIANT, 1, &rgsabound);
var.vt = VT_EMPTY;
long ix;
ix = 0;
SafeArrayPutElement(psa, &ix, &var);
ix= 1;
SafeArrayPutElement(psa, &ix, &var);
ix = 2;
var.vt = VT_BSTR;
var.bstrVal =sTableName.AllocSysString(); //表名 sTableName
SafeArrayPutElement(psa, &ix, &var);
var.vt = VT_BSTR;
ix = 3;
var.bstrVal =sFileNameEN.AllocSysString();//字段名
SafeArrayPutElement(psa, &ix, &var);
Array.vt = VT_ARRAY|VT_VARIANT;
Array.parray = psa;
pAdoAccess->m_pRecordset = pAdoAccess->GetActiveConnection()->OpenSchema(adSchemaColumns,&Array);
//IS_NULL = 1 表示字段可以为空 0 表示必填
ISNullSet = (pAdoAccess->m_pRecordset->Fields->GetItem("IS_NULLABLE")->Value.boolVal == -1)?TRUE:FALSE;//是否允许为空
_bstr_t column_name = pAdoAccess->m_pRecordset->Fields->GetItem("COLUMN_NAME")->Value;//字段名
OrdinalPostion = pAdoAccess->m_pRecordset->Fields->GetItem("ORDINAL_POSITION")->Value;//字段序号
Field *fd = pAdoAccess->m_pRecordset->Fields->GetItem("DESCRIPTION");
if (fd->GetValue().vt != VT_NULL)
{
_bstr_t column_discription = fd->Value;
CString sNote;
sNote.Format(_T("%s"), (LPCTSTR)column_discription);
sFileNameCN = (LPCTSTR)column_discription;
}
else
{
sFileNameCN = sFileNameEN;
}
//int NUMERIC_PRECISION = m_pRecordset->Fields->GetItem("NUMERIC_PRECISION")->Value;
//int NUMERIC_SCALE = m_pRecordset->Fields->GetItem("NUMERIC_SCALE")->Value;
return TRUE;
}
BOOL CDataControl::GetFilePkName(const CString& sTableName,std::vector<CString>& sPkName,CADORecordset* pAdoAccess)
{
SAFEARRAY FAR* psa = NULL;
SAFEARRAYBOUND rgsabound;
_variant_t var;
_variant_t Array;
rgsabound.lLbound = 0;
rgsabound.cElements = 3;
psa = SafeArrayCreate(VT_VARIANT, 1, &rgsabound);
var.vt = VT_EMPTY;
long ix;
ix = 0;
SafeArrayPutElement(psa, &ix, &var);
ix= 1;
SafeArrayPutElement(psa, &ix, &var);
ix = 2;
var.vt = VT_BSTR;
var.bstrVal =sTableName.AllocSysString(); //表名 sTableName
SafeArrayPutElement(psa, &ix, &var);
Array.vt = VT_ARRAY|VT_VARIANT;
Array.parray = psa;
pAdoAccess->m_pRecordset = pAdoAccess->GetActiveConnection()-> OpenSchema(adSchemaPrimaryKeys,&Array); //adSchemaColumns
while(!pAdoAccess->IsEOF())
{
_bstr_t column_name = pAdoAccess->m_pRecordset->Fields->GetItem("COLUMN_NAME")->Value;
_bstr_t column_PK= pAdoAccess->m_pRecordset-> Fields-> GetItem( "PK_NAME")-> Value;
sPkName.push_back((LPCTSTR)column_name);
pAdoAccess->MoveNext();
}
return TRUE;
}C++ 树层级存储
用了一个map来记录所有的层级关系,然后从root找起,依次找出所有的节点…
// 用的是tinyXML读取
BOOL CXmlRead::ReadGroupInfo( std::map<CString, std::vector<std::pair<CString, BOOL>>> &mapGroup )
{
// 载入文件
TiXmlDocument *doc = new TiXmlDocument(PATH);
if (!doc->LoadFile())
{
delete doc;
return FALSE;
}
// 获取根节点
TiXmlElement *pRoot = doc->FirstChildElement(_T("TableGroup"));
ASSERT(pRoot);
if (pRoot == NULL)
{
delete doc;
return FALSE;
}
mapGroup.clear();
std::vector<std::pair<CString, BOOL>> vecTable;
TiXmlElement *pNode = dynamic_cast<TiXmlElement *>(pRoot->FirstChildElement());
while (pNode != NULL)
{
// 节点属性
CString strSubName = pNode->Attribute(_T("Name"));
vecTable.push_back(std::make_pair(strSubName, TRUE));
ASSERT(_T("Group") == (CString)(pNode->Value()));
if(!ReadNode(pNode, mapGroup))
{
return FALSE;
}
// 下一关键字节点
pNode = dynamic_cast<TiXmlElement *>(pNode->NextSiblingElement());
}
mapGroup[_T("ROOT")] = vecTable;
delete doc;
return TRUE;
}
BOOL CXmlRead::ReadNode(TiXmlElement *pNode, std::map<CString, std::vector<std::pair<CString, BOOL>>> &mapGroup)
{
// 每次添加的新节点应该是之前没有出现过的,否则会死循环
CString strNodeName = pNode->Attribute(_T("Name"));
if(mapGroup.end() != mapGroup.find(strNodeName)) return FALSE;
std::vector<std::pair<CString, BOOL>> vecTable;
TiXmlElement *pSubNode = dynamic_cast<TiXmlElement *>(pNode->FirstChildElement());
while (pSubNode != NULL)
{
// 节点名
CString strSub = pSubNode->Value();
// 节点属性
CString strSubName = pSubNode->Attribute(_T("Name"));
if(_T("Group") == strSub)
{
vecTable.push_back(std::make_pair(strSubName, TRUE));
if(!ReadNode(pSubNode, mapGroup))
{
return FALSE;
}
}
else if(_T("Table") == strSub)
{
vecTable.push_back(std::make_pair(strSubName, FALSE));
}
// 下一关键字节点
pSubNode = dynamic_cast<TiXmlElement *>(pSubNode->NextSiblingElement());
}
mapGroup[strNodeName] = vecTable;
return TRUE;
}其实vector里面的bool是可以不要的,最初加这个只是为了区分树节点和叶节点…
C++ 获取某目录下的全部文件
特别需要注意的是,每个文件夹下有.和..两个文件夹分别代表当前目录和上级目录(根目录的..代表当前目录)…IsDot就是用来检测当前是不是.或..的函数
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;
}使用正则做公式有效性判断…