c/c++

从内存中加载动态库(二)

九月鹰飞 — Fri, 28 Jul 2006 04:57:00 GMT

<PRE>
五、加载类的源代码。（编译环境vc6,win98）

typedef BOOL (__stdcall *ProcDllMain)(HINSTANCE, DWORD, LPVOID );

class CMemLoadDll
{
public:
CMemLoadDll();
~CMemLoadDll();
BOOL MemLoadLibrary( void* lpFileData , int DataLength); // Dll file data buffer
FARPROC MemGetProcAddress(LPCSTR lpProcName);
private:
BOOL isLoadOk;
BOOL CheckDataValide(void* lpFileData, int DataLength);
int CalcTotalImageSize();
void CopyDllDatas(void* pDest, void* pSrc);
BOOL FillRavAddress(void* pBase);
void DoRelocation(void* pNewBase);
int GetAlignedSize(int Origin, int Alignment);
private:
ProcDllMain pDllMain;

private:
DWORD pImageBase;
PIMAGE_DOS_HEADER pDosHeader;
PIMAGE_NT_HEADERS pNTHeader;
PIMAGE_SECTION_HEADER pSectionHeader;
};

CMemLoadDll::CMemLoadDll()
{
isLoadOk = FALSE;
pImageBase = NULL;
pDllMain = NULL;
}
CMemLoadDll::~CMemLoadDll()
{
if(isLoadOk)
{
  ASSERT(pImageBase != NULL);
  ASSERT(pDllMain   != NULL);
  //脱钩，准备卸载dll
  pDllMain((HINSTANCE)pImageBase,DLL_PROCESS_DETACH,0);
  VirtualFree((LPVOID)pImageBase, 0, MEM_RELEASE);
}
}

//MemLoadLibrary函数从内存缓冲区数据中加载一个dll到当前进程的地址空间，缺省位置0x10000000
//返回值：成功返回TRUE , 失败返回FALSE
//lpFileData: 存放dll文件数据的缓冲区
//DataLength: 缓冲区中数据的总长度
BOOL CMemLoadDll::MemLoadLibrary(void* lpFileData, int DataLength)
{
if(pImageBase != NULL)
{
return FALSE; //已经加载一个dll，还没有释放，不能加载新的dll
}
//检查数据有效性，并初始化
if(!CheckDataValide(lpFileData, DataLength))return FALSE;
//计算所需的加载空间
int ImageSize = CalcTotalImageSize();
if(ImageSize == 0) return FALSE;

// 分配虚拟内存
void *pMemoryAddress = VirtualAlloc((LPVOID)0x10000000, ImageSize,
     MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(pMemoryAddress == NULL) return FALSE;
else
{
  CopyDllDatas(pMemoryAddress, lpFileData); //复制dll数据，并对齐每个段
  //重定位信息
  if(pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress >0
   && pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size>0)
  {
   DoRelocation(pMemoryAddress);
  }
  //填充引入地址表
  if(!FillRavAddress(pMemoryAddress)) //修正引入地址表失败
  {
   VirtualFree(pMemoryAddress,0,MEM_RELEASE);
   return FALSE;
  }
  //修改页属性。应该根据每个页的属性单独设置其对应内存页的属性。这里简化一下。
  //统一设置成一个属性PAGE_EXECUTE_READWRITE
  unsigned long old;
  VirtualProtect(pMemoryAddress, ImageSize, PAGE_EXECUTE_READWRITE,&old);
}
//修正基地址
pNTHeader->OptionalHeader.ImageBase = (DWORD)pMemoryAddress;

//接下来要调用一下dll的入口函数，做初始化工作。
pDllMain = (ProcDllMain)(pNTHeader->OptionalHeader.AddressOfEntryPoint +(DWORD) pMemoryAddress);
BOOL InitResult = pDllMain((HINSTANCE)pMemoryAddress,DLL_PROCESS_ATTACH,0);
if(!InitResult) //初始化失败
{
  pDllMain((HINSTANCE)pMemoryAddress,DLL_PROCESS_DETACH,0);
  VirtualFree(pMemoryAddress,0,MEM_RELEASE);
  pDllMain = NULL;
  return FALSE;
}

isLoadOk = TRUE;
pImageBase = (DWORD)pMemoryAddress;
return TRUE;
}

//MemGetProcAddress函数从dll中获取指定函数的地址
//返回值：成功返回函数地址 , 失败返回NULL
//lpProcName: 要查找函数的名字或者序号
FARPROC CMemLoadDll::MemGetProcAddress(LPCSTR lpProcName)
{
if(pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress == 0 ||
pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size == 0)
return NULL;
if(!isLoadOk) return NULL;

DWORD OffsetStart = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
DWORD Size = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;

PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)((DWORD)pImageBase + pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
int iBase = pExport->Base;
int iNumberOfFunctions = pExport->NumberOfFunctions;
int iNumberOfNames = pExport->NumberOfNames; //<= iNumberOfFunctions
LPDWORD pAddressOfFunctions = (LPDWORD)(pExport->AddressOfFunctions + pImageBase);
LPWORD pAddressOfOrdinals = (LPWORD)(pExport->AddressOfNameOrdinals + pImageBase);
LPDWORD pAddressOfNames = (LPDWORD)(pExport->AddressOfNames + pImageBase);

int iOrdinal = -1;

if(((DWORD)lpProcName & 0xFFFF0000) == 0) //IT IS A ORDINAL!
{
iOrdinal = (DWORD)lpProcName & 0x0000FFFF - iBase;
}
else //use name
{
int iFound = -1;

  for(int i=0;i<iNumberOfNames;i++)
  {
   char* pName= (char* )(pAddressOfNames[i] + pImageBase);
   if(strcmp(pName, lpProcName) == 0)
   {
    iFound = i; break;
   }
  }
  if(iFound >= 0)
  {
   iOrdinal = (int)(pAddressOfOrdinals[iFound]);
  }
}

if(iOrdinal < 0 || iOrdinal >= iNumberOfFunctions ) return NULL;
else
{
  DWORD pFunctionOffset = pAddressOfFunctions[iOrdinal];
  if(pFunctionOffset > OffsetStart && pFunctionOffset < (OffsetStart+Size))//maybe Export Forwarding
   return NULL;
  else return (FARPROC)(pFunctionOffset + pImageBase);
}

}

// 重定向PE用到的地址
void CMemLoadDll::DoRelocation( void *NewBase)
{
/* 重定位表的结构：
// DWORD sectionAddress, DWORD size (包括本节需要重定位的数据)
// 例如 1000节需要修正5个重定位数据的话，重定位表的数据是
// 00 10 00 00   14 00 00 00      xxxx xxxx xxxx xxxx xxxx 0000
// -----------   -----------      ----
// 给出节的偏移总尺寸=8+6*2     需要修正的地址           用于对齐4字节
// 重定位表是若干个相连，如果address 和 size都是0 表示结束
// 需要修正的地址是12位的，高4位是形态字，intel cpu下是3
*/
//假设NewBase是0x600000,而文件中设置的缺省ImageBase是0x400000,则修正偏移量就是0x200000
DWORD Delta = (DWORD)NewBase - pNTHeader->OptionalHeader.ImageBase;

//注意重定位表的位置可能和硬盘文件中的偏移地址不同，应该使用加载后的地址
PIMAGE_BASE_RELOCATION pLoc = (PIMAGE_BASE_RELOCATION)((unsigned long)NewBase
  + pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
while((pLoc->VirtualAddress + pLoc->SizeOfBlock) != 0) //开始扫描重定位表
{
  WORD *pLocData = (WORD *)((int)pLoc + sizeof(IMAGE_BASE_RELOCATION));
  //计算本节需要修正的重定位项（地址）的数目
  int NumberOfReloc = (pLoc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION))/sizeof(WORD);
  for( int i=0 ; i < NumberOfReloc; i++)
  {
   if( (DWORD)(pLocData[i] & 0xF000) == 0x00003000) //这是一个需要修正的地址
   {
    // 举例：
    // pLoc->VirtualAddress = 0x1000;
    // pLocData[i] = 0x313E; 表示本节偏移地址0x13E处需要修正
    // 因此 pAddress = 基地址 + 0x113E
    // 里面的内容是 A1 ( 0c d4 02 10) 汇编代码是： mov eax , [1002d40c]
    // 需要修正1002d40c这个地址
    DWORD * pAddress = (DWORD *)((unsigned long)NewBase + pLoc->VirtualAddress + (pLocData[i] & 0x0FFF));
    *pAddress += Delta;
   }
  }
  //转移到下一个节进行处理
  pLoc = (PIMAGE_BASE_RELOCATION)((DWORD)pLoc + pLoc->SizeOfBlock);
}
}

//填充引入地址表
BOOL CMemLoadDll::FillRavAddress(void *pImageBase)
{
// 引入表实际上是一个 IMAGE_IMPORT_DESCRIPTOR 结构数组，全部是0表示结束
// 数组定义如下：
//
    // DWORD   OriginalFirstThunk;         // 0表示结束，否则指向未绑定的IAT结构数组
    // DWORD   TimeDateStamp;
    // DWORD   ForwarderChain;             // -1 if no forwarders
    // DWORD   Name;                       // 给出dll的名字
    // DWORD   FirstThunk;                 // 指向IAT结构数组的地址(绑定后，这些IAT里面就是实际的函数地址)
unsigned long Offset = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress ;
if(Offset == 0) return TRUE; //No Import Table
PIMAGE_IMPORT_DESCRIPTOR pID = (PIMAGE_IMPORT_DESCRIPTOR)((unsigned long) pImageBase + Offset);
while(pID->Characteristics != 0 )
{
  PIMAGE_THUNK_DATA pRealIAT = (PIMAGE_THUNK_DATA)((unsigned long)pImageBase + pID->FirstThunk);
  PIMAGE_THUNK_DATA pOriginalIAT = (PIMAGE_THUNK_DATA)((unsigned long)pImageBase + pID->OriginalFirstThunk);
  //获取dll的名字
  char buf[256]; //dll name;
  BYTE* pName = (BYTE*)((unsigned long)pImageBase + pID->Name);
  for(int i=0;i<256;i++)
  {
   if(pName[i] == 0)break;
   buf[i] = pName[i];
  }
  if(i>=256) return FALSE; // bad dll name
  else buf[i] = 0;
  HMODULE hDll = GetModuleHandle(buf);
  if(hDll == NULL)return FALSE; //NOT FOUND DLL
  //获取DLL中每个导出函数的地址，填入IAT
  //每个IAT结构是：
  // union { PBYTE ForwarderString;
        //   PDWORD Function;
        //   DWORD Ordinal;
        //   PIMAGE_IMPORT_BY_NAME AddressOfData;
  // } u1;
  // 长度是一个DWORD ，正好容纳一个地址。
  for(i=0; ;i++)
  {
   if(pOriginalIAT[i].u1.Function == 0)break;
   FARPROC lpFunction = NULL;
   if(pOriginalIAT[i].u1.Ordinal & IMAGE_ORDINAL_FLAG) //这里的值给出的是导出序号
   {
    lpFunction = GetProcAddress(hDll, (LPCSTR)(pOriginalIAT[i].u1.Ordinal & 0x0000FFFF));
   }
   else //按照名字导入
   {
    //获取此IAT项所描述的函数名称
    PIMAGE_IMPORT_BY_NAME pByName = (PIMAGE_IMPORT_BY_NAME)
     ((DWORD)pImageBase + (DWORD)(pOriginalIAT[i].u1.AddressOfData));
//    if(pByName->Hint !=0)
//     lpFunction = GetProcAddress(hDll, (LPCSTR)pByName->Hint);
//    else
     lpFunction = GetProcAddress(hDll, (char *)pByName->Name);
   }
   if(lpFunction != NULL)   //找到了！
   {
    pRealIAT[i].u1.Function = (PDWORD) lpFunction;
   }
   else return FALSE;
  }

//move to next
pID = (PIMAGE_IMPORT_DESCRIPTOR)( (DWORD)pID + sizeof(IMAGE_IMPORT_DESCRIPTOR));
}
return TRUE;
}

//CheckDataValide函数用于检查缓冲区中的数据是否有效的dll文件
//返回值：是一个可执行的dll则返回TRUE，否则返回FALSE。
//lpFileData: 存放dll数据的内存缓冲区
//DataLength: dll文件的长度
BOOL CMemLoadDll::CheckDataValide(void* lpFileData, int DataLength)
{
//检查长度
if(DataLength < sizeof(IMAGE_DOS_HEADER)) return FALSE;
pDosHeader = (PIMAGE_DOS_HEADER)lpFileData; // DOS头
//检查dos头的标记
if(pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) return FALSE; //0x5A4D : MZ

//检查长度
if((DWORD)DataLength < (pDosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS)) ) return FALSE;
//取得pe头
pNTHeader = (PIMAGE_NT_HEADERS)( (unsigned long)lpFileData + pDosHeader->e_lfanew); // PE头
//检查pe头的合法性
if(pNTHeader->Signature != IMAGE_NT_SIGNATURE) return FALSE;  //0x00004550 : PE00
if((pNTHeader->FileHeader.Characteristics & IMAGE_FILE_DLL) == 0) //0x2000 : File is a DLL
  return FALSE;
if((pNTHeader->FileHeader.Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) == 0) //0x0002 : 指出文件可以运行
  return FALSE;
if(pNTHeader->FileHeader.SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER)) return FALSE;

//取得节表（段表）
pSectionHeader = (PIMAGE_SECTION_HEADER)((int)pNTHeader + sizeof(IMAGE_NT_HEADERS));
//验证每个节表的空间
for(int i=0; i< pNTHeader->FileHeader.NumberOfSections; i++)
{
if((pSectionHeader[i].PointerToRawData + pSectionHeader[i].SizeOfRawData) > (DWORD)DataLength)return FALSE;
}
return TRUE;
}

//计算对齐边界
int CMemLoadDll::GetAlignedSize(int Origin, int Alignment)
{
return (Origin + Alignment - 1) / Alignment * Alignment;
}
//计算整个dll映像文件的尺寸
int CMemLoadDll::CalcTotalImageSize()
{
int Size;
if(pNTHeader == NULL)return 0;
int nAlign = pNTHeader->OptionalHeader.SectionAlignment; //段对齐字节数

// 计算所有头的尺寸。包括dos, coff, pe头和段表的大小
Size = GetAlignedSize(pNTHeader->OptionalHeader.SizeOfHeaders, nAlign);
// 计算所有节的大小
for(int i=0; i < pNTHeader->FileHeader.NumberOfSections; ++i)
{
  //得到该节的大小
  int CodeSize = pSectionHeader[i].Misc.VirtualSize ;
  int LoadSize = pSectionHeader[i].SizeOfRawData;
  int MaxSize = (LoadSize > CodeSize)?(LoadSize):(CodeSize);

  int SectionSize = GetAlignedSize(pSectionHeader[i].VirtualAddress + MaxSize, nAlign);
  if(Size < SectionSize)
   Size = SectionSize; //Use the Max;
}
return Size;
}
//CopyDllDatas函数将dll数据复制到指定内存区域，并对齐所有节
//pSrc: 存放dll数据的原始缓冲区
//pDest:目标内存地址
void CMemLoadDll::CopyDllDatas(void* pDest, void* pSrc)
{
// 计算需要复制的PE头+段表字节数
int HeaderSize = pNTHeader->OptionalHeader.SizeOfHeaders;
int SectionSize = pNTHeader->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
int MoveSize = HeaderSize + SectionSize;
//复制头和段信息
memmove(pDest, pSrc, MoveSize);

//复制每个节
for(int i=0; i < pNTHeader->FileHeader.NumberOfSections; ++i)
{
  if(pSectionHeader[i].VirtualAddress == 0 || pSectionHeader[i].SizeOfRawData == 0)continue;
  // 定位该节在内存中的位置
  void *pSectionAddress = (void *)((unsigned long)pDest + pSectionHeader[i].VirtualAddress);
  // 复制段数据到虚拟内存
  memmove((void *)pSectionAddress,
       (void *)((DWORD)pSrc + pSectionHeader[i].PointerToRawData),
    pSectionHeader[i].SizeOfRawData);
}

//修正指针，指向新分配的内存
//新的dos头
pDosHeader = (PIMAGE_DOS_HEADER)pDest;
//新的pe头地址
pNTHeader = (PIMAGE_NT_HEADERS)((int)pDest + (pDosHeader->e_lfanew));
//新的节表地址
pSectionHeader = (PIMAGE_SECTION_HEADER)((int)pNTHeader + sizeof(IMAGE_NT_HEADERS));
return ;
}

谨依此文祝贺我在VCKBASE里升级。
iwaswzq 2006/7/27
</PRE>

从内存中加载动态库(一)

九月鹰飞 — Fri, 28 Jul 2006 04:55:00 GMT

<PRE>

    程序使用动态库DLL一般分为隐式加载和显式加载两种，分别对应两种链接情况。本文主要讨论显式加载的技术问题。我们知道，要显式加载一个DLL，并取得其中导出的函数地址一般是通过如下步骤：
    (1) 用LoadLibrary加载dll文件，获得该dll的模块句柄；
    (2) 定义一个函数指针类型，并声明一个变量；
    (3) 用GetProcAddress取得该dll中目标函数的地址，赋值给函数指针变量；
    (4) 调用函数指针变量。

这个方法要求dll文件位于硬盘上面。现在假设我们的dll已经位于内存中，比如通过脱壳、解密或者解压缩得到，能不能不把它写入硬盘文件，而直接从内存加载呢？答案是肯定的。经过多天的研究，非法操作了N次，修改了M个BUG，死亡了若干脑细胞后，终于有了初步的结果，下面做个总结与大家共享。

一、加载的步骤

    由于没有相关的资料说明，只能凭借感觉来写。首先LoadLibrary是把dll的代码映射到exe进程的虚拟地址空间中，我们要实现的也是这个。所以先要弄清楚dll的文件结构。好在这个比较简单，它和exe一样也是PE文件结构，关于PE文件的资料很多，阅读一番后，基本上知道了必须做的几个工作：
    (1)判断内存数据是否是一个有效的DLL。这个功能通过函数CheckDataValide完成。原型是：
        BOOL CMemLoadDll::CheckDataValide(void* lpFileData, int DataLength);
    (2)计算加载该DLL所需的虚拟内存大小。这个功能通过函数CalcTotalImageSize完成。原型是：
        int CMemLoadDll::CalcTotalImageSize();
    (3)将DLL数据复制到所分配的虚拟内存块中。该功能通过函数CopyDllDatas完成。要注意段对齐。
        void CMemLoadDll::CopyDllDatas(void* pDest, void* pSrc);
    (4)修正基地重定位数据。这个功能通过函数DoRelocation完成。原型是：
        void CMemLoadDll::DoRelocation( void *NewBase);
    (5)填充该DLL的引入地址表。这个功能由函数FillRavAddress完成。原型是：
        BOOL CMemLoadDll::FillRavAddress(void *pImageBase);
    (6)根据DLL每个节的属性设置其对应内存页的读写属性。我这里做了简化，所有内存区域都设置成一样的读写属性。
    (7)调用入口函数DllMain，完成初始化工作。这一步我一开始忽略了，所以总是发现自己加载的dll和LoadLibrary加载的dll有些不同(我把整块内存区域保存到两个文件中进行比较，够晕的)。只是最近猜想到还需要这一步。
    (8)保存dll的基地址（即分配的内存块起始地址）,用于查找dll的导出函数。从现在开始这个dll已经完全映射到了进程的虚拟地址空间，可以使用它了。
    (9)不需要dll的时候，释放所分配的虚拟内存。

二、要说明的几个问题

   (1)目前CMemLoadDll仅仅针对win32 动态库，没有考虑mfc常规和扩展dll。
   (2)只考虑使用dll中的函数，对于导出类的dll，由于通常都是隐式链接，所以也没有考虑。导出变量的dll虽然也是隐式链接，但是通过查找函数的方法也可以找到该变量，不过在取值的时候一定要符合dll中对变量的定义，比如dll中导出的是一个int变量，则得到该变量在dll中的地址后，需要强制转换成int*指针，然后取值。
   (3)查找函数的功能通过函数
       FARPROC CMemLoadDll::MemGetProcAddress(LPCSTR lpProcName);
实现，参数是dll导出的函数（或者变量）的名字。这里必须注意函数名修饰，通常不加extern"C"的函数，编译以后在dll中导出的都是修饰名，比如：
    在dll头文件中: extern __declspec(dllexport) int nTestDll;
    在.dll中的导出符号变成 ?nTestDll@@3HA
   所以，为了能够找到我们需要的函数，必须在.h中添加extern "C"修饰。最好是给dll加一个def文件，里面明确给出每个函数的导出名字。
   (4)PE中的内容比较多，有些细节没有考虑。比如CheckDataValide函数中没有考虑dll对操作系统版本的要求。
   (5)PE文件中的节有很多种。可以从节表（或者叫做区块表）中一一找到。而且每个节的属性都不同。例如：.text, .data, .rsrc, .crt等等。由于这个代码基于手头已有的pe文件资料，对于不熟悉的节，在映射dll数据的时候没有考虑是否需要处理。
   (6)一开始把dll映射到进程的地址空间以后，我试图直接使用GetProcAddress查找函数。最初我认为LoadLibrary返回的HINSTANCE值是0x10000000，把它传递给GetProcAddress可以找到目标函数，而我也把dll映射到0x10000000这个地址，但是当我把这个值传递给GetProcAddress的时候，发现无法找到函数，用GetLastError得到错误码一看是无效句柄的错误，这才明白原来LoadLibrary在加载dll的时候，同时创建了一个句柄放入进程的句柄表，而我们要做这个工作是比较麻烦的，所以只能自己写一个查找函数。
   (7)释放dll所占据的虚拟内存，原来我使用
      VirtualFree((LPVOID)pImageBase, 0,MEM_FREE);
后来发现有问题，应该使用 VirtualFree((LPVOID)pImageBase, 0, MEM_RELEASE);
   (8)MemGetProcAddress不仅支持通过函数名查找，还支持通过导出序号查找函数。例如下面的用法：
DLLFUNCTION fDll = (DLLFUNCTION)a.MemGetProcAddress((LPCTSTR)1);

三、创建测试用的DLL，工程的名字取"TestDll"

    用VC向导创建一个WIN32 DLL工程，里面选择“导出一些符号”，为了测试需要，对源代码进行如下修改：
（1）头文件
    // This class is exported from the TestDll.dll
    class TESTDLL_API CTestDll {
        public:
CTestDll(void);
    };
    extern TESTDLL_API int nTestDll;
    //要修改的地方，添加了extern "C" 和 char *参数：
    extern "C" TESTDLL_API int fnTestDll(char *);
（2）cpp文件
      a. 添加 #include "stdlib.h"
      b. DllMain中
  case DLL_PROCESS_DETACH:
   nTestDll = 12345;
   break;
      c. 初始化变量
         TESTDLL_API int nTestDll=654321;
      d. 修改函数
         TESTDLL_API int fnTestDll(char *p)
         {
         if(p == NULL)
      return nTestDll;
         else
      return atoi(p);
          }

四、创建测试工程。使用一个dlg工程，测试代码如下：

    假设 DllNameBuffer里面保存有dll文件的路径
CFile f;
if(f.Open(DllNameBuffer,CFile::modeRead))
{
  int FileLength = f.GetLength();
  void *lpBuf = new char[FileLength];
  f.Read(lpBuf, FileLength);
  f.Close();

  CMemLoadDll a;
  if(a.MemLoadLibrary(lpBuf, FileLength)) //加载dll到当前进程的地址空间
  {
   typedef int (*DLLFUNCTION)(char *);
   DLLFUNCTION fDll = (DLLFUNCTION)a.MemGetProcAddress("fnTestDll");
   if(fDll != NULL)
   {
    MessageBox("找到函数！！");
    CString str;
    str.Format("Result is: %d & %d",fDll(NULL), fDll("100"));
    MessageBox(str);
   }
   else
   {
    DWORD err = GetLastError();
    CString str;
    str.Format("Error: %d",err);
    MessageBox(str);
   }
  }

delete[] lpBuf;
}

五、加载类源代码。（在后续贴子里面给出）

iwaswzq 2006/7/27
</PRE>

奇怪的SetCheck

九月鹰飞 — Sun, 19 Feb 2006 08:01:00 GMT

一、问题的提出

CTreeCtrl有个属性TVS_HASBUTTONS，如果创建控件的时候加上了这个属性，则在每个节点的左侧
都有一个按钮，用来表示节点的选择状态。通过两个函数SetCheck / GetCheck来设置和获取指定
节点的选择状态。

但是奇怪的是，在对话框中按照常规的方法使用了SetCheck，最后CTreeCtrl并没有显示节点被选
中，下面是测试例子：

   1、用wizard创建一个对话框工程，并且在上面放置一个CTreeCtrl控件。
   2、设置CTreeCtrl的属性，"More Styles"里面选中"Check Boxes"，给它加上复选框。
   3、对话框初始化的时候，给CTreeCtrl控件添加节点，并设置选中。代码如下：

BOOL CTestCheckDlg::OnInitDialog()
{
CDialog::OnInitDialog();
。。。
// TODO: Add extra initialization here
HTREEITEM hRoot = m_Tree.InsertItem("Root");
m_Tree.SetCheck(hRoot);
m_Tree.InsertItem("Child1", hRoot);
m_Tree.InsertItem("Child2", hRoot);
m_Tree.Expand(hRoot, TVE_EXPAND );

return TRUE;
}

但是，对话框运行以后，树控件的根节点并没有显示被选中。用GetCheck测试，返回FALSE。但是
如果在OnInitDialog里面SetCheck以后，立刻用GetCheck测试，发现返回的却是TRUE。

进一步测试可以发现，对话框显示以后，任何时候再次使用SetCheck都没有问题了。

二、问题分析

由于无法直接监视树控件根节点状态的变化，为了弄清楚树控件究竟是什么时候修改了我们设置的
check状态，我在其他消息响应函数中进一步用GetCheck检查，发现对话框在第一次OnPaint的时候
，树控件根节点的check状态还是选中的，但紧接着下个消息来到后，它的状态就发生了改变。我
思来想去肯定是树控件本身的问题。可能是它第一次画自己的时候，修改了每个节点的选择状态。

但是它为何这么做？我开始猜测和它的图表列表有关系。为了验证这个想法，加入下面的代码：

CImageList* pStateIcon = m_Tree.GetImageList(TVSIL_STATE);
int nItem = (pStateIcon == NULL)?(0):(pStateIcon->GetImageCount());
CString str;
str.Format("Count of State Icon: %d\n", nItem);
TRACE(str);

果然不出所料，测试结果发现，在OnInitDialog里面，树控件虽然添加了数据，但是它的State Icon
并没有加载，ImageList是空的。一旦它显示自己后，ImageList就不是NULL了，里面的图标数目是3。
也就是说它使用了3个图标。

显然是树控件在创建自己的时候，并没有加载所需的图标列表，而是在显示的时候，发现需要后，它才
加载，并且重新复位了每个节点的选择状态。它之所以这么做，我想可能是出于效率方面的考虑。也就
是说，如果用户没有添加TVS_HASBUTTONS，那么它就不需要这个图标列表了。

三、解决问题

既然知道了问题的所在，那么鉴于在对话框初始化的时候，设置树控件的数据和选择状态是一个常规的
做法，我就不打算修改这些代码的位置，而采用提前给它加载图标列表的方法。方法如下：

   1、在资源中添加一个位图资源IDB_BITMAP1，尺寸拉伸成48*16。（长48，高16，共三个图标）
   2、在位图上面画三个图标，每个大小都是16*16，第二个是X，第三个是选择（对勾）。至于第一个
      的用途，还不清楚。
   3、在对话框的头文件中，添加一个CImageList对象：
      CImageList m_ImageList;
   4、在对话框初始化函数中，添加如下代码：

m_ImageList.Create(IDB_BITMAP1, 16,3,RGB(255,255,255));
m_Tree.SetImageList(&m_ImageList, TVSIL_STATE);

运行以后，发现问题已经解决。只不过树控件的状态图标已经换成了自己的，可以弄得更好看一些。

以上代码的测试环境[win98 / vc6.0]

2006/2/17 iwaswzq

scanf中有意思的过滤

九月鹰飞 — Thu, 20 Oct 2005 10:46:00 GMT

1、scanf输入数据的时候，它的参数表达式有过滤功能。比如：
int i,j,k;
scanf("%d空格%d空格%d空格",&i,&j,&k);
你输入 10空格20空格30回车， scanf开始处理，它把10 读入到i中，看到后面的空格，会自动删除之。虽然
最后30后面没有空格也没有关系。但是如果10后面或者20后面没有空格，或者是其它字符，比如：
10,20空格30回车，输入就会出错。当然多个空格也没有关系，例如：10空格空格20空格30回车。因为扫描
整数的时候会自动删除多余的空格。
如果用scanf("%d空格,%d,空格%d",&i,&j,&k); //注意空格和逗号的顺序，则输入和结果的比较是：
10空格,20,空格30               //和表达式正好匹配，没有问题
10,20,30                               //ok
10,空格20,空格30               //ok
10,空格20空格,30               //出错
10空格20空格30                 //更错
2、过滤具有多重功能。例如下面输入字符的例子：
char c;
for(;;)
{
  scanf("%cabc",&c);
  if(c=='q')break;
  printf("c=%c\n",c);
}
则在输入的字符串里面遇到a, ab, abc, 会自动删除。例如输入：
1a2ab3abc4bc5ba6aa7abca8
输出结果是：
c=1
c=2
c=3
c=4
c=b
c=c
c=5
c=b
c=6
c=a
c=7
c=a
c=8

可以看到实际的过滤情况，但是有意思的一点是scanf不会过滤bc，而且一旦成功过滤一组输入，
接下来的数据就会直接读入，例如遇到aa的情况，过滤掉a以后，下一个a被成功读入。

而且上面的例子，如果输入一些数据后，再输入q退出，则还会输出一个c=，表明读入了一个回车符，
真的很奇怪。可以如下测试：
char c;
for(;;)
{
  scanf("%cabc",&c);
  if(c=='q')break;
  if(c!='\n')
   printf("c=%c\n",c);
  else
   printf("haha!\n");
}
3、再做进一步的测试，会发现更诡异的事情，把上面的代码改成：
  scanf("%c abc",&c); //注意abc前面的空格
你会发现输入q以后，程序并没有退出，还需要再输入一个字符。改成scanf("%c",&c);就没有问题了。

上述现象应该不是什么语法问题，是scanf这个函数本身的代码产生的问题。诸如下面这样的代码：
char a[20];
scanf("%[A-Za-z ]s", a);
因为很少用到它，我不想再去研究了，谁感兴趣谁去弄吧，呵呵。

关于 Gallery

九月鹰飞 — Wed, 20 Jul 2005 18:22:00 GMT

关于 Gallery

-----------------------------------------------------
前言：

想在工程里面插入一个ActiveX控件，却发现我的VC找不到
任何注册的东西，深感奇怪。看了一晚上msdn中关于 Gallery
的东西，终于有所收获，不敢独享，特此贴出。
-----------------------------------------------------

说明：

Visual C++ 6 通过 Gallery 实现代码重用。你可以在自己的工程中从这里
添加很多东西，从而增强自己程序的功能，比如图像控件、图表控件等等。

Gallery里面的控件被分成两类：

1、Visual C++ Components
2、Registered ActiveX Controls

以及其它用户自己产生的控件类和第三方的控件或者组件。

*****************************************************
一、访问 Gallery

在“工程”菜单，选择“ Add To Project”，然后点“Components and Controls”命令，则vc打开 Gallery 对话框，和打开文件对话框一样。

Gallery 目录里面缺省包含两个子目录，一个是“Visual C++ Components”，一个是“Registered ActiveX Controls”，另外其它的目录都是用户自己的控件目录。

这个 Gallery 目录一般位于Visual C++软件目录下面的MSDEV98子目录里面。对于这些个目录有如下
说明：

（1）、不允许移动或者改名。如果你这么做了，这些目录会自动创建新的。
（2）、里面包含的仅仅是各种控件的快捷方式和注册信息。
（3）、不要用来保存其它文件。

*****************************************************
二、关于两个子目录

Visual C++ Components 目录包含了系统中注册的Visual C++ 组件(.DLL files)的快捷方式。Registered ActiveX Controls 目录包含的是所有在系统中注册的ActiveX控件(包括.OCX或者.DLL)的link。

这些组件要么是安装VC的时候自动注册到系统中的，要么是后来运行某些程序的时候注册的。

每次打开 Gallery 目录，它都会根据当前注册表的内容，重新产生所有注册组件的链接。也就是说:

1、如果你在这个目录里面删除了指向某个注册组件的link，则下次打开 Gallery的时候，这个link会再次出现。

2、如果你删除了一个注册组件，但是没有unregister它，则 Gallery中仍然有指向它的link。但是这个link不能用了。

3、如果你复制了一个组件在你的计算机上，但是没有注册，则它的link不会出现在 Gallery 里面。

*****************************************************
三、向工程中添加 Gallery 中的组件

使用 Gallery，可以很方便的向工程中添加组件或者 ActiveX 控件。或者重用以前的代码。只需选中要添加的东西，然后单击"Insert"按钮。

添加的具体效果取决于你选中什么。例如，如果你选择的是一个用户自定义组件(OGX)，则会在你的工程里面添加头文件和CPP文件以及相应的资源。

假如你选择插入的是一个 ActiveX控件，则Gallery会生成一个叫做ActiveX control wrapper的编程接口，控件通过这个接口和你的程序进行通讯。这个接口包括一个头文件和一个cpp文件。

一般来说，每个 Gallery 目录中的控件都有帮助，你可以选择一个，然后点"More Info"按钮查看。其它第三方的控件一般也有自己的文档可以参考。

注意，下列工程中无法从 Gallery 中添加 ActiveX控件：

1、不使用MFC的ATL工程；
2、Win32 工程；
3、其它任何没有clw 文件的工程。

这些类型的工程中如果需要使用某个 ActiveX 控件，可以从对话框编辑器的右键菜单中选择“Insert ActiveX Control”，然后从打开的对话框中选择你需要的控件。如果该对话框是基于mfc的，则wizards会支持它，但是控件本身不会出现在那个controls资源工具条上面。因为我的VC的 Gallery 里面没有任何东西，所以我用这个方法在我的对话框上面加上了ActiveX控件，但是可惜的是没有添加任何头文件和cpp文件，因此看不到这个控件的源代码，感到愤愤不平。

下面是向工程中添加注册 ActiveX 控件的步骤：
1、打开工程的工作空间
2、如果该工作空间中有多个工程，请在“工程”菜单中选择“设置活动工程”命令。
3、在“工程”菜单，选择“添加工程”，然后选择"Components and Controls" 。
4、在 Gallery 中打开Registered ActiveX Controls 文件夹，选择你所需的控件。然后点“Insert”按钮。
5、出现请求确认对话框，确认即可。

添加组件的步骤如下：

1，2，3同上面。
4、在 Gallery 中打开 Visual C++ Components 文件夹，然后选择你需要的组件。然后点“Insert”。
5、然后一般会出现一个提示框，让你设置特定组件的属性和选项，有些组件是不需要任何设置信息的。
6、点 OK以后，Gallery会把组件中包含的文件和资源复制到当前的活动工程中。对于有些组件仅仅是修改你的工程文件和资源，而不会添加任何文件。你可以使用 ClassView 查看新加入的组件类，或者到ResourceView中查看新加入的资源。

*****************************************************
四、向 Gallery 中添加东西

你可以通过Gallery 搜集整理自己的重用代码。这一点很有用途，各位看官切记。

可以把自己工程中的某个vc++类转换成组件保存到Gallery中。 Gallery会自动创建一个组件（OGX）打包你的类，包括所有相关的文件和资源。你在也不需要使用剪切/复制的方法了，同时再也不用担心名字冲突了，因为 Gallery 会自动处理所有命名问题。

注意不要把ATL 类添加到 Gallery中。对于 ATL类，可能显示添加成功，但是实际上它们包含的某些东西无法保存到 Gallery中，所以以后使用的时候会产生问题。

添加类的步骤如下：
1、打开包含目标类的工程，如果里面有多个project，注意设置活动工程。
2、在 ClassView 中鼠标右击目标类，然后选择 "Add to Gallery"菜单命令。
然后在 Gallery 中就会创建一个新的文件夹，名字就是当前工程的名字，你打开它就可以看到里面有一个OGX组件。其它的工程就可以使用它了。多方便啊！
在 Gallery中，你可以重命名、删除或者复制OGX组件，只需用鼠标右键单击它们，然后选择相应命令即可。

不过需要注意的是，最好不要把OGX组件移动到那两个缺省 Gallery目录中。

如果要添加第三方组件或者ActiveX控件到 Gallery 中，需要运行该控件的安装程序，安装程序所做的工作一般包括：下载控件，注册，在Registered ActiveX Controls 文件夹中添加快捷方式等。但是并不是所有控件都有安装程序，如果没有的话，就无法添加到 Gallery中了。

我上面说到的那个问题，虽然控件成功地注册到系统中，但是 Gallery 中找不到它。用鼠标右键的方法加入工程中又不好用，幸运的是我下载了一个示例工程，里面用到了这个控件，所以里面也有这个控件的一个类（h和cpp)，我采用上面所说的保存类的方法，在 Gallery中保存了一个OGX组件，这样一来，其它工程就可以使用了,很是方便，哈哈。

有些时候注册组件是通过 Regsvr32.exe ，有些情况下是通过inf文件安装的。

*****************************************************
五、管理 Gallery里面的东西

Gallery最初把组件分成两组，放在两个缺省子文件夹中，你可以按照自己的喜好组织和管理里面的组件。例如创建新的文件夹保存新的组件，可以删除、重命名或者重组你自己创建的文件夹。

当你创建了自己的某个文件夹以后，你可以在资源管理器中，把两个缺省文件夹里面的组件拖动到你的文件夹中。因为都是快捷方式，所以下次启动 Gallery，缺省目录里面的link会自动恢复。而你的文件夹里面已经有link了。

这些操作都很简单，就不说了。需要注意的是如果要删除Gallery里面的组件，需要先使用

Regsvr32.exe /u

命令卸载组件，然后从Gallery中删除。

虽然你可以删除两个缺省子文件夹，但是下次启动Visual C++，它们又会出现。而且里面的快捷方式(link)也会恢复。但是切记，如果删除了 Gallery 目录，则下次启动Visual C++后，虽然 Gallery 目录恢复，但是里面就空了。

iwaswzq 2005/7/21凌晨

宏定义里面的换行

九月鹰飞 — Thu, 07 Jul 2005 15:12:00 GMT

有个朋友要把嵌入式汇编代码块定义成宏，例如

void func()
{
...
    __asm {
           mov     dx, 0
           mov     ax, 0
           };
   ...
}
用宏定义这个代码块的时候因为必须使用续行符\，所以想来想去只有这样了：

#define MYINLINEASM __asm{ \
             __asm      mov     dx, 0 \
             __asm      mov     ax, 0 \
             __asm      };

（其实括号不要也行，因为这里每行都有__asm关键字了）

void func()
{
   ...
MYINLINEASM
   ...
}

否则的话，会由于续行符的问题引起编译错误，例如：
#define MYINLINEASM __asm{ \
                                                 mov     dx, 0 \
                                                  mov     ax, 0 \
                                                   };

这样就不行了。过去几天了，又想起来，特此记之。

关于可变参数函数的若干问题

九月鹰飞 — Mon, 20 Jun 2005 07:17:00 GMT

关于可变参数函数的若干问题

iwaswzq 2005/6/15

------------------------------------------------------------------

c/c++支持可变参数的函数，即函数的参数是不确定的。

一、为什么要使用可变参数的函数？

一般我们编程的时候，函数中形式参数的数目通常是确定的，在调用时要依次给出与形式参数对应的所有实际参数。但在某些情况下希望函数的参数个数可以根据需要确定，因此c语言引入可变参数函数。这也是c功能强大的一个方面，其它某些语言，比如fortran就没有这个功能。

典型的可变参数函数的例子有大家熟悉的printf()、scanf()等。

二、c/c++如何实现可变参数的函数？

为了支持可变参数函数，C语言引入新的调用协议，即C语言调用约定 __cdecl 。采用C/C++语言编程的时候，默认使用这个调用约定。如果要采用其它调用约定，必须添加其它关键字声明，例如WIN32 API使用PASCAL调用约定，函数名字之前必须加__stdcall关键字。

采用C调用约定时，函数的参数是从右到左入栈，个数可变。由于函数体不能预先知道传进来的参数个数，因此采用本约定时必须由函数调用者负责堆栈清理。举个例子：

   //C调用约定函数
   int __cdecl Add(int a, int b)
   {
      return (a + b);
   }

   函数调用：
   Add(1, 2);
   //汇编代码是：
   push        2            ;参数b入栈
   push        1            ;参数a入栈
   call        @Add         ;调用函数。其实还有编译器用于定位函数的表达式这里把它省略了
   add         esp,8        ;调用者负责清栈

如果调用函数的时候使用的调用协议和函数原型中声明的不一致，就会导致栈错误，这是另外一个话题，这里不再细说。

另外c/c++编译器采用宏的形式支持可变参数函数。这些宏包括va_start、va_arg和va_end等。之所以这么做，是为了增加程序的可移植性。屏蔽不同的硬件平台造成的差异。

支持可变参数函数的所有宏都定义在stdarg.h 和 varargs.h中。例如标准ANSI形式下，这些宏的定义是：

typedef char * va_list; //字符串指针

#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap) ( ap = (va_list)0 )

使用宏_INTSIZEOF是为了按照整数字节对齐指针，因为c调用协议下面，参数入栈都是整数字节（指针或者值）。

三、如何定义这类的函数。

可变参数函数在不同的系统下，采用不同的形式定义。

1、用ANSI标准形式时，参数个数可变的函数的原型声明是：

type funcname(type para1, type para2, ...);

关于这个定义，有三点需要说明：

一般来说，这种形式至少需要一个普通的形式参数，可变参数就是通过三个'.'来定义的。所以"..."不表示省略，而是函数原型的一部分。type是函数返回值和形式参数的类型。
例如：

int MyPrintf(char const* fmt, ...);

但是，我们也可以这样定义函数：

void MyFunc(...);

但是，这样的话，我们就无法使用函数的参数了，因为无法通过上面所讲的宏来提取每个参数。所以除非你的函数代码中的确没有用到参数表中的任何参数，否则必须在参数表中使用至少一个普通参数。

注意，可变参数只能位于函数参数表的最后。不能这样：

void MyFunc(..., int i);

2、采用与UNIX 兼容系统下的声明方式时，参数个数可变的函数原型是：

type funcname(va_alist);

但是要求函数实现的时候，函数名字后面必须加上va_dcl。例如：

#include <varargs.h>
int average( va_list );

void main( void )
{
。。。//代码
}

/* UNIX兼容形式*/
int average( va_alist )
va_dcl
{
。。。//代码
}

这种形式不需要提供任何普通的形式参数。type是函数返回值的类型。va_dcl是对函数原型声明中参数va_alist的详细声明，实际是一个宏定义。根据平台的不同，va_dcl的定义稍有不同。

在varargs.h中，va_dcl的定义后面已经包括了一个分号。因此函数实现的时候，va_dcl后不再需要加上分号了。

3、采用头文件stdarg.h编写的程序是符合ANSI标准的，可以在各种操作系统和硬件上运行；而采用头文件varargs.h的方式仅仅是为了与以前的程序兼容，两种方式的基本原理是一致的，只是在语法形式上有一些细微的区别。所以一般编程的时候使用stdarg.h。下面的所有例子代码都采用ANSI标准格式。

四、可变参数函数的基本使用方法

下面通过若干例子，说明如何实现可变参数函数的定义和调用。

//================================ 例子程序1 ===============
#include < stdio.h >
#include < string.h >
#include < stdarg.h >

/* 函数原型声明，至少需要一个确定的参数，注意括号内的省略号 */
int demo( char *, ... );

void main( void )
{
demo("DEMO", "This", "is", "a", "demo!", "\0");
}

int demo( char *msg, ... )
{
va_list argp; /* 定义保存函数参数的结构 */
int argno = 0; /* 纪录参数个数 */
char *para; /* 存放取出的字符串参数 */

// 使用宏va_start, 使argp指向传入的第一个可选参数，
// 注意 msg是参数表中最后一个确定的参数，并非参数表中第一个参数
va_start( argp, msg );

   while (1)
{
  //取出当前的参数，类型为char *
  //如果不给出正确的类型，将得到错误的参数
  para = va_arg( argp, char *);

    if ( strcmp( para, "\0") == 0 ) /* 采用空串指示参数输入结束 */
   break;
  printf("参数 #%d 是: %s\n", argno, para);
    argno++;
   }
  va_end( argp ); /* 将argp置为NULL */
   return 0;
}

//输出结果
参数 #0 是: This
参数 #1 是: is
参数 #2 是: a
参数 #3 是: demo!

注意到上面的例子没有使用第一个参数，下面的例子将使用所有参数

//================================ 例子程序2 ===============

#include <stdio.h>
#include <stdarg.h>
int average( int first, ... ); //输入若干整数，求它们的平均值

void main( void )
{
/* 调用3个整数(-1表示结尾) */
printf( "Average is: %d\n", average(2,3,4, -1));

/*调用4个整数*/
printf( "Average is: %d\n", average(5,7,9, 11,-1));

/*只有结束符的调用*/
printf( "Average is: %d\n", average(-1) );
}

/* 返回若干整数平均值的函数 */
int average( int first, ... )
{
int count = 0, sum = 0, i = first;
va_list marker;

   va_start( marker, first ); //初始化
   while( i != -1 )
   {
      sum += i; //先加第一个参数
      count++;
      i = va_arg( marker, int);//取下一个参数
   }
   va_end( marker );
   return( sum ? (sum / count) : 0 );
}

//输出结果
Average is: 3
Average is: 8
Average is: 0

五、关于可变参数的传递问题

有人问到这个问题，假如我定义了一个可变参数函数，在这个函数内部又要调用其它可变参数函数，那么如何传递参数呢？上面的例子都是使用宏va_arg逐个把参数提取出来使用，能否不提取，直接把它们传递给另外的函数呢？

我们先看printf的实现：

int __cdecl printf (const char *format, ...)
{
        va_list arglist;
        int buffing;
        int retval;

va_start(arglist, format); //arglist指向format后面的第一个参数

。。。//不关心其它代码
retval = _output(stdout,format,arglist); //把format格式和参数传递给output函数

。。。//不关心其它代码
return(retval);
}

我们先模仿这个函数写一个：

#include <stdio.h>
#include <stdarg.h>

int mywrite(char *fmt, ...)
{
     va_list arglist;
     va_start(arglist, fmt);
     return printf(fmt,arglist);
}

void main()
{
int i=10, j=20;
char buf[] = "This is a test";
double f= 12.345;
mywrite("String: %s\nInt: %d, %d\nFloat :%4.2f\n", buf, i, j, f);
}

运行一下看看，哈，错误百出。仔细分析原因，根据宏的定义我们知道 arglist是一个指针，它指向第一个可变的参数，但是所有的参数都位于栈中，所以arglist指向栈中某个位置，通过arglist的值，我们可以直接查看栈里面的内容：

arglist -> 指向栈里面，内容包括

0067FD78 E0 FD 67 00 //指向字符串"This is a test"
0067FD7C 0A 00 00 00 //整数 i 的值
0067FD80 14 00 00 00 //整数 j 的值
0067FD84 71 3D 0A D7 //double 变量 f, 占用8个字节
0067FD88 A3 B0 28 40
0067FD8C 00 00 00 00

如果直接调用 printf(fmt, arglist); 仅仅是把arglist指针的值0067FD78入栈，然后把格式字符串入栈，相当于调用：

printf(fmt, 0067FD78);

自然这样的调用肯定会出现错误。

我们能不能逐个把参数提取出来，再传递给其它函数呢？先考虑一次性把所有参数传递进去的问题。

如果调用的是系统库函数，这种情况下是不可能的。因为提取参数是在运行态，而参数入栈是在编译的时候确定的。无法让编译器预知运行态的事情给出正确的参数入栈代码。而我们在运行态虽然可以提取每个参数，但是无法将参数一次性全部压栈，即使使用汇编代码实现起来也是很困难的，因为不单是一个简单的push代码就可以做到。

如果接受参数的函数也是我们自己写的，自然我们可以把arglist指针入栈，然后在函数中自己解析arglist指针里面的参数，逐个提取出来处理。但是这样做似乎没有什么意义，一方面，这个函数没有必要也做成可变参数函数，另一方面直接在第一个函数中解析参数，然后处理不是更简单么？

我们唯一可以做到的是，逐个解析参数，然后循环中调用其它可变参数函数，每次传递一个参数。这里又有一个问题，就是参数表中的不可变参数的传递问题，有些情况下不能简单的传递，以上面的例子为例，通常我们解析参数的同时，还需要解析格式字符串：

#include <windows.h>
#include <stdio.h>
#include <stdarg.h>

//测试一下这个，开个玩笑
void t(...)
{
printf("\n");
}

int mywrite(char *fmt, ...)
{
va_list arglist;
va_start(arglist, fmt);

char temp[255];
strcpy(temp, fmt); //Copy the Format string
char Format[255];

char *p = strchr(temp,'%');
int i=0;
int iParam;
double fParam;
while(p != NULL)
{
   while((*p<'a' || *p>'z') && (*p!=0) ) p++;
   if(*p == 0)break;
   p++;

   //格式字符串
   int nChar = p - temp;
   strncpy(Format,temp, nChar);
   Format[nChar] = 0;
   //参数
   if(Format[nChar-1] != 'f')
   {
    iParam = va_arg( arglist, int);
    printf(Format, iParam);
   }
   else
   {
    fParam = va_arg( arglist, double);
    printf(Format, fParam);
   }

   i++;
   if(*p == 0) break;
   strcpy(temp, p);
   p = strchr(temp, '%');
}
if(temp[0] != 0)
   printf(temp);

return i;

}

void main()
{
int i=10, j=20;
char buf[] = "This is a test";
double f= 123.456;
mywrite("String: %s\nInt: %d, %d\nFloat :%4.2f\nEnd", buf, i, j, f, 0);
t("aaa", i);
}

//输出：
String: This is a test
Int: 10, 20
Float :123.46
End

当然这里的解析是不完善的。
----------------------------------------
iwaswzq 2005/6/15

星星来看看

九月鹰飞 — Sun, 12 Jun 2005 01:41:00 GMT

关于这个问题，曾经讨论过，apnic也总结过关于“在构造函数中调用构造函数”的问题。

#include <iostream>
using namespace std;

class A
{
public:
    A();
    A(int i);
    int data;

    ~A();
};

A::A()
{
    cout<< " call A::A() " << endl;
    data = 0;
}
A::A(int i)
{
    cout<< " call A::A(int) " << endl;
    data = i;
}
A::~A()
{
    cout<< " call A::~A() " << endl;
}

class B:public A
{
public:
    B();
    B(int i);
    ~B();
};

B::B(int i)
{
    cout<< " call B::B(int) " << endl;
    B();
}

B::B():A(10)
{
    cout<< " call B::B() " << endl;
}
B::~B()
{
    cout<< " call B::~B() " << endl;
}
void main()
{
    B b(2);
    cout<< b.data << endl;
}
一般认为B b(2);应该调用B::B(int i)构造函数，里面调用B();
而B::B()调用的是A(10)构造函数，A::A(int i)会把data设置成i，就是10。
但是运行结果是0：

call A::A()          //调用B(int)之前，先调用基类的缺省构造函数
call B::B(int)       //调用B(int)
call A::A(int)       //由于B()中使用了初始化列表，这里先调用了A(int)
call B::B()          //然后才调用了B()
call B::~B()         //居然调用析构函数
call A::~A()         //自然也会调用基类的析构函数
0                     //结果
call B::~B()         //再次析构，销毁对象
call A::~A()

从上面的调用过程中，可以看到只要调用类的构造函数，就会在栈中创建对象，是这样子的么？

但是如果改成构造函数中调用父类的构造函数：
B::B(int i)
{
cout<< " call B::B(int) " << endl;
A::A(i); //call this constructor.
}
运行结果是：
call A::A()
call B::B(int)
call A::A(int)
call A::~A()
0
call B::~B()
call A::~A()
少了对B的构造函数和析构函数的调用，但是仍然调用了~A(); 这是为什么？

看来只能改成这样：
B::B(int i):A(i)
{
cout<< " call B::B(int) " << endl;
}
运行结果是：
call A::A(int)
call B::B(int)
2
call B::~B()
call A::~A()
只有这个结果是正确的，难道父类的构造函数只能在初始化列表中使用？

浮点数格式及整数到浮点数的简单算法

九月鹰飞 — Thu, 16 Dec 2004 02:50:00 GMT

关于volatile关键字的说明以及测试

九月鹰飞 — Sat, 04 Dec 2004 21:33:00 GMT