vc技巧常用函数
void Log(LPCTSTR szFormat, ...)
{
CString strMessage;
va_list argList;
va_start( argList, szFormat );
strMessage.FormatV( szFormat, argList );
va_end( argList );
CString strIndent(' ', g_indent*2);
_tprintf(_T("%s%s\n"), (LPCTSTR)strIndent, (LPCTSTR)strMessage);
ATLTRACE(_T("%s%s\n"), (LPCTSTR)strIndent, (LPCTSTR)strMessage);
}
static HRESULT FormatDateTime( SYSTEMTIME *pSystemTime, char *pResult, size_t max )
{
GetDateFormat( GetThreadLocale(), DATE_SHORTDATE, pSystemTime, NULL, pResult, (int)max );
size_t len = _tcslen( pResult );
if ( (max - len) < 2 )
return E_FAIL; // if not enough room in buffer
pResult[ len ] = ' ';
len++;
GetTimeFormat( GetThreadLocale(), TIME_NOSECONDS, pSystemTime, NULL, pResult + len, (int)(max - len) );
return S_OK;
}
ATL::CSimpleString<CObject> strs;//出错
ATL::CSimpleMap<CString,CString> maps;
ATL::CSimpleArray<CString> arrs;
CAtlArray<CString> g_aObjects;
mfc afxtls_.h CSimpleList lists;
CArray< DWORD > aidProcesses;
ATL::CThreadPool<CMyWorker> pool;
CComSafeArray<VARIANT> m_sa;
CWinThread
总结：
reinterpret_cast 将一个类型指针转换为另一个类型指针
const_cast 用于去除指针变量的常属性，将它转换为一个对应指针类型的普通变量，反过来也可以将一个非常量指针转换为一个常量指针变量
static_cast 用于转换基本类型和具有继承关系的类新之间转换,不太用于指针类型的之间的转换
dynamic_cast 只能在继承类对象的指针之间或引用之间进行类型转换
#include "stdafx.h"
//#include <iostream.h>
int main(void)
{
//reinterpret_cast
//将一个类型指针转换为另一个类型指针，这种在转换不修改指针变量值数据存放格式
//只需在编译时重新解释指针的类型，他可以将指针转化为一个整型数但不能用于非指针的转换
double d=9.3;
double* pd = &d;
int* pi = reinterpret_cast<int *> (pd);
class A{};
class B{};
A* pa = new A;
B* pb=reinterpret_cast<B*>(pa); //将pa 转为B
long j=reinterpret_cast<long> (pa);//指针转换为整数
// int i=9;
// double x=reinterpret_cast<double>(i); //reinterpret_cast不能用于非指针的转换
//const_cast
//1.用于去除指针变量的常属性，将它转换为一个对应指针类型的普通变量，
//2.反过来也可以将一个非常量指针转换为一个常量指针变量
//3.他无法将一个非指针的常量转换为普通变量
//example: const i=10;
// int j=const_cast<int>(i); //无法转换
const int ppp=998;
const int* pca=&ppp;
int* p=const_cast<int*>(pca);//将它转换为一个对应指针类型的普通变量，去除了const;
const A* paa=new A;
A * ppppa=const_cast<A*> (paa);//它转换为一个对应指针类型的普通变量，去除了const;
int * pii=0;//反过来也可以将一个非常量指针转换为一个常量指针变量
const int* piiic=const_cast<const int *>(pii);
//////////////////////////////////////////////////////////////////////////////////
//static_cast
//用于转换基本类型和具有继承关系的类新之间转换
//static_cast不太用于指针类型的之间的转换，他的效率没有reinterpret_cast的效率高
int in=99;
double dn=static_cast<double> (in);//用于转换基本类型和具有继承关系的类新之间转换
class Base{};
class derv:public Base{};
derv dd;
Base bbbb=static_cast<Base>(dd);//具有继承关系的类型之间转换
//static_cast不太用于指针类型的之间的转换，他的效率没有reinterpret_cast的效率高
Base *pb1=new Base;
derv *pder=static_cast<derv*>(pb1);//基类转继承类
derv* pder1=new derv;
Base* pbase1=static_cast<Base*>(pder1);//继承类指针转父类指针
//dynamic_cast
//1.只能在继承类对象的指针之间或引用之间进行类型转换
//2.这种转换并非在编译时，而是在运行时，动态的
//3.没有继承关系，但被转换的类具有虚函数对象的指针进行转换
derv* dp=new derv;
Base* bv=dynamic_cast<Base *>(dp);//继承类对象的指针之间进行类型转换
derv dpp;//继承类对象引用之间进行类型转换
Base &b=dynamic_cast<Base&>(dpp);
class AA{
virtual int fun(){ return 0;}
virtual ~AA(){}
};
class BB{
};
//没有继承关系，但被转换的类具有虚函数对象的指针进行转换，编译可通过
AA* pAA=new AA;
BB* pBB=dynamic_cast<BB *>(pAA);
//没有继承关系，被转换的类也没有有虚函数对象的指针进行转换，编译不能通过
//BB* pBBB=new BB;
//AA* pAAA=dynamic_cast<AA*>(pBBB);
return 1;
}
CString GetCurDir()
{
TCHAR sDrive[_MAX_DRIVE];
TCHAR sDir[_MAX_DIR];
TCHAR sFilename[_MAX_FNAME],Filename[_MAX_FNAME];
TCHAR sExt[_MAX_EXT];
GetModuleFileName(AfxGetInstanceHandle(), Filename,_MAX_PATH);
_tsplitpath(Filename,sDrive,sDir,sFilename,sExt);
CString homeDir(CString(sDrive)+CString(sDir));
int nLen = homeDir.GetLength();
if(homeDir.GetAt(nLen-1)!=_T('\\'))
homeDir+=_T('\\');
return homeDir;
}
//获取程序所在目录
CString GetDir()
{
CString strPath;
::GetModuleFileName(NULL,strPath.GetBuffer(MAX_PATH),MAX_PATH);
strPath.ReleaseBuffer();
strPath = strPath.Left(strPath.ReverseFind(_T('\\')) +1 );
return strPath;
}
CFileDialog dlg( TRUE , "(*.exe)|*.exe","*.*" ,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT ,"程序文件(*.exe)");
if(dlg.DoModal()==IDOK)
{
SetDlgItemText(IDC_EDIT_FILE_PATH,dlg.GetPathName());
}
//通过窗体名关闭进程
HWND hNoteWnd = FindWindow(NULL, "无标题 - 记事本");
if ( hNoteWnd == NULL )
{
return -1;
}
DWORD dwNotePid = 0;
GetWindowThreadProcessId(hNoteWnd, &dwNotePid);
if ( dwNotePid == 0 )
{
return -1;
}
HANDLE hNoteHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwNotePid);
if ( hNoteHandle == NULL )
{
return -1;
}
TerminateProcess(hNoteHandle, 0);
CloseHandle(hNoteHandle);
void GetSysInfo()
{
char szComputerName[MAXBYTE] = { 0 };
char szUserName[MAXBYTE] = { 0 };
unsigned long nSize = MAXBYTE;
OSVERSIONINFO OsVer;
OsVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&OsVer);
if ( OsVer.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
if ( OsVer.dwMajorVersion == 5 && OsVer.dwMinorVersion == 1 )
{
printf("Windows XP %s \r\n", OsVer.szCSDVersion);
}
else if ( OsVer.dwMajorVersion == 5 && OsVer.dwMinorVersion == 0)
{
printf("Windows 2K \r\n");
}else{
printf("%d %d\n",OsVer.dwMajorVersion,OsVer.dwMinorVersion);
}
}else
{
printf("Ohter System \r\n");
}
GetComputerName(szComputerName, &nSize);
printf("Computer Name is %s \r\n", szComputerName);
nSize = MAXBYTE;
GetUserName(szUserName, &nSize);
printf("User Name is %s \r\n", szUserName);
}
//isNumber("1024",0);
int isNumber(const char *z, int *realnum){
if( *z=='-' || *z=='+' ) z++;
if( !isdigit(*z) ){
return 0;
}
z++;
if( realnum ) *realnum = 0;
while( isdigit(*z) ){ z++; }
if( *z=='.' ){
z++;
if( !isdigit(*z) ) return 0;
while( isdigit(*z) ){ z++; }
if( realnum ) *realnum = 1;
}
if( *z=='e' || *z=='E' ){
z++;
if( *z=='+' || *z=='-' ) z++;
if( !isdigit(*z) ) return 0;
while( isdigit(*z) ){ z++; }
if( realnum ) *realnum = 1;
}
return *z==0;
}
//int=>string //1、使用sprintf 2、_itoa //<sstream.h> stringstream() int hello=4; stringstream ss; ss<<hello; string s=ss.str(); //调用string的方法 cout<<s.c_str()<<endl;
void WriteLog(char *fmt,...)
{
FILE *fp;
va_list args;
char modname[128];
if((fp =fopen("c:\\hookapi.log", "a")) !=NULL)
{
va_start(args,fmt);
GetModuleFileName(NULL, modname, sizeof(modname));
fprintf(fp, "%s: ", modname);
// fprintf(fp,"Netxx: ");
vfprintf(fp, fmt, args);
fprintf(fp, "\n");
fclose(fp);
va_end(args);
}
}
char * GetErrString(char *str, DWORD errcode)
{
LPVOID lpbuf;
if(FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
errcode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpbuf,
0,
NULL
))
{
lstrcpy(str, (char *)lpbuf);
LocalFree(lpbuf);
}
return str;
}
ansic和Unicode转换函数：
char *UNICODEconvertANSI(LPWSTR wText,int targetCodePage)
{
//wchar_t wText[20] = {L"宽字符转换实例!OK!"};
int dwNum = WideCharToMultiByte(targetCodePage,NULL,wText,-1,NULL,0,NULL,FALSE);
char *psText;
psText = new char[dwNum+1];
memset(psText,0,dwNum);
WideCharToMultiByte (targetCodePage,NULL,wText,-1,psText,dwNum+1,NULL,FALSE);
return psText;
}
LPWSTR ANSIConvertUNCOIDE(char* aText,int sourceCodePage)
{
int len=MultiByteToWideChar(sourceCodePage,NULL,aText,-1,NULL,0);
wchar_t *psText=new wchar_t[len+1];
memset(psText,0,len);
MultiByteToWideChar(sourceCodePage,NULL,aText,-1,psText,len+1);
//psText[len]='\0';
return psText;
}字符连接
wchar_t *STR2WSTR(char *pmb) //narrow string to wide string
{
size_t requiredSize = mbstowcs(NULL, pmb, 0);
wchar_t *pwc = (wchar_t *)malloc( (requiredSize + 1) * sizeof( wchar_t ));
mbstowcs( pwc, pmb, requiredSize + 1);
return pwc;
}
char *cs(char *str1, char *str2) //connect string
{
size_t newstrlen=strlen(str1)+strlen(str2)+1;
char *newstr=(char*)malloc(newstrlen);
memcpy(newstr,str1,strlen(str1));
memcpy(newstr+strlen(str1),str2,strlen(str2)+1);
return newstr;
}