Rick 's BLOG

C++ 中 XML 库 TinyXML2 的基本使用方法

2026-06-21T03:48:02+08:00

一、前言

TinyXML-2 是一个简单，小型，高效的 C ++ XML 解析器，可以轻松集成到其他程序中。
直接引用源文件的话只需要包含两个文件（h 和 cpp，此外还有个测试文件里面带有 demo）。
TinyXML-2 解析 XML 文档，并以此为基础构建可读取，修改和保存的文档对象模型（DOM）。文档说，在解释 XML 时仅使用 UTF-8 编码，假定所有 XML 为 UTF-8 编码格式。
该库还支持打印到文件或内存，使用 XMLPrinter 类。

GitHub 链接：https://github.com/leethomason/tinyxml2

备用下载链接：tinyxml2-10.0.0.zip

（下载库项目后带有离线英文文档，可以浏览器在线翻译即可）

二、基本使用方法

引入头文件：

#include "tinyxml2.h"

//tinyxml2的类在tinyxml2命名空间
using namespace tinyxml2;

使用 XMLDocument 加载和保存 XML 文件：

//构造一个xml文档类
XMLDocument doc;
//读取文件
//从磁盘加载XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
XMLError error = doc.LoadFile(xmlPath);
//也可以解析字符串
//XMLError tinyxml2::XMLDocument::Parse(const char *xml,size_t nBytes = static_cast<size_t>(-1));
if (error != XMLError::XML_SUCCESS)
return;
//存储到文件，参数2 compact紧凑默认false
doc.SaveFile(xmlPath);

可以借助 XMLDocument 生成节点（元素、属性、文本、注释等），也可以直接 new 生成对象，但还要使用 Insert 方法才能插入到结构中：

//元素
XMLElement * tinyxml2::XMLDocument::NewElement (const char *name)
//注释
XMLComment * tinyxml2::XMLDocument::NewComment (const char *comment)
//文本
XMLText * tinyxml2::XMLDocument::NewText (const char *text)
//XML文件头描述
XMLDeclaration * tinyxml2::XMLDocument::NewDeclaration (const char *text=0)
//未知类型
XMLUnknown * tinyxml2::XMLDocument::NewUnknown (const char *text)

//插入到末尾
XMLNode * tinyxml2::XMLNode::InsertEndChild (XMLNode *addThis)
//插入到开头
XMLNode * tinyxml2::XMLNode::InsertFirstChild (XMLNode *addThis)
//插入到节点的下一个位置
XMLNode * tinyxml2::XMLNode::InsertAfterChild (XMLNode *afterThis, XMLNode *addThis)

删除子节点：

//是否不包含子节点
bool tinyxml2::XMLNode::NoChildren () const
//第一个子节点
const XMLNode * tinyxml2::XMLNode::FirstChild () const
//第一个子元素
const XMLElement * tinyxml2::XMLNode::FirstChildElement (const char *name=0) const
//最后一个子节点
const XMLNode * tinyxml2::XMLNode::LastChild () const
//最后一个子元素
const XMLElement * tinyxml2::XMLNode::LastChildElement (const char *name=0) const
//上一个兄弟节点
const XMLNode * tinyxml2::XMLNode::PreviousSibling () const
//上一个兄弟元素
const XMLElement * tinyxml2::XMLNode::PreviousSiblingElement (const char *name=0) const
//下一个兄弟节点
const XMLNode * tinyxml2::XMLNode::NextSibling () const
//下一个兄弟元素
const XMLElement * tinyxml2::XMLNode::NextSiblingElement (const char *name=0) const

如果要遍历整个文档，可从 XMLDocument 开始遍历，XXXChild + XXXSibling 遍历所有的子节点和兄弟节点。

三、简单完整示例代码

[复制到剪贴板]



#include <iostream>
#include <string>
 
#include "tinyxml2.h"
 
//tinyxml2的类在tinyxml2命名空间
using namespace tinyxml2;
 
//测试生成xml
void create_xml(const char* xmlPath);
//测试解析xml
void parse_xml(const char* xmlPath);
//遍历xml node
void traversal_node(XMLNode* node);
//遍历xml element
void traversal_element(XMLNode* node, int level);
//生成预定格式xml
void create_xml2(const char* xmlPath);
//解析预定义格式xml
void parse_xml2(const char* xmlPath);

int main()
{
    const char* path = "./test.xml";
    create_xml(path);
    parse_xml(path);
 
    const char* path2 = "./test2.xml";
    create_xml2(path2);
    parse_xml2(path2);
 
    system("pause");
    return 0;
}

void create_xml(const char* xmlPath)
{
    std::cout << "\ncreate_xml:" << xmlPath << std::endl;
    //【】构造一个xml文档类
    XMLDocument doc;
    //【】操作文档相关接口
    //创建与此文档关联的新声明。对象的内存由文档管理。
    //如果'text'参数为null，则使用标准声明:
    //<?xml version="1.0" encoding="UTF-8"?>
    XMLDeclaration* declaration = doc.NewDeclaration();
    //创建与此文档关联的新元素。元素的内存由文档管理。
    XMLElement* element = doc.NewElement("ElementA");
    //创建与此文档关联的新注释。注释的内存由文档管理。
    XMLComment* comment = doc.NewComment("My TinyXml2 Test... ...");
    //创建与此文档关联的新文本。文本的存储由文档管理。
    XMLText* text = doc.NewText("Some Test");
    //创建与此文档关联的新的未知节点。对象的内存由文档管理。
    XMLUnknown* unknown = doc.NewUnknown("Unknown");
    //【】创建了节点还要插入文档中
    //添加一个子节点作为最后一个（右）子节点。如果子节点已经是文档的一部分，则将其从其旧位置移至新位置。
    //XMLNode* tinyxml2::XMLNode::InsertEndChild(XMLNode * addThis);
    //添加一个子节点作为第一个（左）子节点。如果子节点已经是文档的一部分，则将其从其旧位置移至新位置。
    //XMLNode* tinyxml2::XMLNode::InsertFirstChild(XMLNode* addThis);
    //在指定的子节点之后添加一个节点。如果子节点已经是文档的一部分，则将其从其旧位置移至新位置。
    //XMLNode* tinyxml2::XMLNode::InsertAfterChild(XMLNode * afterThis, XMLNode * addThis);
    doc.InsertFirstChild(declaration);
    doc.InsertAfterChild(declaration, element);
    doc.InsertEndChild(comment);
    doc.InsertEndChild(text);
    doc.InsertEndChild(unknown);
 
    //【】操作节点相关接口
    //将命名属性设置为对应类型的value
    element->SetAttribute("Level", "A");
    element->SetAttribute("Value", 1992);
    //设置文本
    element->SetText("ElementA text");
    //注释
    element->InsertNewComment("ElementA comment");
    //添加子节点，接口已经带insert功能了
    XMLElement* sub_element = element->InsertNewChildElement("ElementB");
    sub_element->SetAttribute("Level", "B");
    sub_element->SetText("ElementB text");
    sub_element->InsertNewComment("ElementB comment");
 
 
    //【】存储到文件，参数2 compact紧凑默认false
    //结构写的不规范，感觉应该拿一个根节点把那些注释，文本包起来
    //不然解析的时候没法访问啊
    doc.SaveFile(xmlPath);
}

void parse_xml(const char* xmlPath)
{
    std::cout << "\nparse_xml:" << xmlPath << std::endl;
    //【】构造一个xml文档类
    XMLDocument doc;
    //【】读取文件
    //从磁盘加载XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
    XMLError error = doc.LoadFile(xmlPath);
    //也可以解析字符串
    //从字符串解析XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
    //XMLError tinyxml2::XMLDocument::Parse(const char *xml,size_t nBytes = static_cast<size_t>(-1));
    if (error != XMLError::XML_SUCCESS)
        return;
    //注意，实际解析时返回的指针记得判空，不然遇到解析失败异常就遭了
 
    //【】解析根元素
    //返回DOM的根元素。等效于FirstChildElement。要获取第一个节点，请使用FirstChild。
    XMLElement* root = doc.RootElement();
    std::cout << "RootElement name:" << root->Name() << std::endl;
    //获取第一个子元素，或者选择具有指定名称的第一个子元素。
    XMLElement* first = doc.FirstChildElement("ElementA");
    //给定一个属性名称，Attribute返回该名称的属性的值；如果不存在，则返回null。
    std::cout << "FirstChildElement Attr Level:" << first->Attribute("Level") << std::endl;
    std::cout << "FirstChildElement Attr Value:" << first->Attribute("Value") << std::endl;
    //如果'this'的第一个Child是XMLText，则GetText返回Text节点的字符串，否则返回null。
    std::cout << "FirstChildElement Text:" << first->GetText() << std::endl;
 
    //【】解析子元素
    XMLElement* sub = root->FirstChildElement("ElementB");
    std::cout << "SubElement Attr Level:" << sub->Attribute("Level") << std::endl;
    std::cout << "SubElement Text:" << sub->GetText() << std::endl;

        //【】
    //可使用FirstChild+NextSibling遍历子节点
    std::cout << "\ntraversal_xml:" << std::endl;
    traversal_node(&doc);
    //或者FirstChildElement+NextSiblingElement遍历子元素
    std::cout << "\ntraversal_element:" << std::endl;
    traversal_element(&doc, 0);
}
 
void traversal_node(XMLNode* node)
{
    if (!node)
        return;
    for (XMLNode* current = node->FirstChild(); current != nullptr; current = current->NextSibling())
    {
        XMLNode* temp = current;
        if (temp->Value() != nullptr)
            std::cout << temp->Value() << std::endl;
        if (!temp->NoChildren())
            traversal_node(temp);
    }
}

void traversal_element(XMLNode* node, int level)
{
    if (!node)
        return;
    for (XMLElement* current = node->FirstChildElement(); current != nullptr; current = current->NextSiblingElement())
    {
        XMLElement* temp = current;
        //这里我使用点号来表示层级缩进
        std::cout << std::string(level * 5, '.') << temp->Name() << std::endl;
        if (temp->GetText() != nullptr)
            std::cout << std::string(level * 5, '.') << "> Text" << ":" << temp->GetText() << std::endl;
        const XMLAttribute* attr = temp->FirstAttribute();
        if (attr != nullptr)
            std::cout << std::string(level * 5, '.') << "> Attr" << ":" << attr->Value() << std::endl;
        if (temp->FirstChildElement() != nullptr)
            traversal_element(temp, level + 1);
    }
}

void create_xml2(const char* xmlPath)
{
    std::cout << "\ncreate_xml2:" << xmlPath << std::endl;
    //【】构造一个xml文档类
    XMLDocument doc;
 
    //【】构建我们的xml数据结构
    XMLDeclaration* declaration = doc.NewDeclaration();
    doc.InsertFirstChild(declaration);
    //创建与此文档关联的新元素。元素的内存由文档管理。
    XMLElement* root = doc.NewElement("Root");
    doc.InsertEndChild(root);
    //子节点
    XMLElement* group_a = root->InsertNewChildElement("GroupA");
    group_a->SetAttribute("Type", "A");
    XMLElement* a_1 = group_a->InsertNewChildElement("Name");
    a_1->SetText("中文");
    XMLElement* a_1_sub = a_1->InsertNewChildElement("Content");
    a_1_sub->SetText("111111");
    XMLElement* a_2 = group_a->InsertNewChildElement("Name");
    a_2->SetText("English");
    XMLElement* a_2_sub = a_2->InsertNewChildElement("Content");
    a_2_sub->SetText("222222");
    XMLElement* a_3 = group_a->InsertNewChildElement("Name");
    a_3->SetText("123");
    XMLElement* a_3_sub = a_3->InsertNewChildElement("Content");
    a_3_sub->SetText("333333");
    XMLElement* group_b = root->InsertNewChildElement("GroupB");
    group_b->SetAttribute("Type", "B");
    XMLElement* group_c = root->InsertNewChildElement("GroupC");
    group_c->SetAttribute("Type", "C");
 
    //【】存储到文件，参数2 compact紧凑默认false
    doc.SaveFile(xmlPath);
}

void parse_xml2(const char* xmlPath)
{
    std::cout << "\nparse_xml2:" << xmlPath << std::endl;
    //【】构造一个xml文档类
    XMLDocument doc;
    //【】读取文件
    //从磁盘加载XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
    XMLError error = doc.LoadFile(xmlPath);
    //也可以解析字符串
    //从字符串解析XML文件。成功返回XML_SUCCESS（0），或者返回errorID。
    //XMLError tinyxml2::XMLDocument::Parse(const char *xml,size_t nBytes = static_cast<size_t>(-1));
    if (error != XMLError::XML_SUCCESS)
        return;
    //注意，实际解析时返回的指针记得判空，不然遇到解析失败异常就遭了
 
    //【】解析根节点
    //返回DOM的根元素。等效于FirstChildElement。要获取第一个节点，请使用FirstChild。
    XMLElement* root = doc.RootElement();
    //【】查找
    XMLElement* find_ele = root->FirstChildElement("GroupA");
    if (find_ele) {
        std::cout << find_ele->Name() << std::endl;
        const XMLAttribute* attr = find_ele->FindAttribute("Type");
        if (attr) {
            std::cout << attr->Name() << ":" << attr->Value() << std::endl;
        }
        XMLElement* find_sub = find_ele->FirstChildElement("Name");
        if (find_sub && find_sub->GetText()) {
            std::cout << find_sub->GetText() << std::endl;
        }
    }

    //【】遍历
    std::cout << "\ntraversal_element:" << std::endl;
    traversal_element(&doc, 0);
}

vc6、vc7、vc8、vc9、vc10、vc11、vc12、vc14、vc15各代表Visual Studio C++什么版本

2026-06-21T03:48:02+08:00

单来说vs发布版本与vc版本对应关系如下所示：

Visual Studio 6 ： vc6
Visual Studio 2003 ： vc7
Visual Studio 2005 ： vc8
Visual Studio 2008 ： vc9
Visual Studio 2010 ： vc10
Visual Studio 2012 ： vc11
Visual Studio 2013 ： vc12
Visual Studio 2015 ： vc14
Visual Studio 2017 ： vc15

向现有的MFC项目添加ATL支持。

2026-06-21T03:48:02+08:00

如果在现有的MFC项目中实现了依赖ATL基础库的Com对象时，直接运行会出现异常：
CComCritSecLock<CComCriticalSection> lock(_pAtlModule->m_csStaticDataInitAndTypeInfo, false);

像上面的代码在atlcom.h中，_pAtlModule 的值为空，没有初始化。

网上说可以通过添加类向导，然后选择添加ATL支持到现有的MFC项目。

实际测试，发现老项目在添加时会失败。只有新建的MFC项目可以添加成功。

然后，添加的结果也不满意，多了一些不需要的东西。
1，添加了idl文件，会在编译时生成tlb库。
2，在资源中添加了tlb库，会将tlb库链接到程序资源中。
3，添加了rgs文件（注册表项目）。
4，会在调用com对象时进行自注册操作（将rgs导入注册表）。

上面这些都是我不想要的，我只是想干干净净的，让我实现的com对象可以正常调用传递参数就行了。
不需要在系统中注册com组件。

对过对比分析新的mfc项目添加atl支持后的代码，发现添加支持很简单。
在现有的cpp文件中添加如下代码即可。

[复制到剪贴板]



class CMFCApplication1Module :public ATL::CAtlMfcModule
{
};

CMFCApplication1Module _AtlModule;

就像上面这样，定义一个atl的app类。
再实例一个对象即可。

VS 2005打开类视图

2026-06-21T03:48:02+08:00

比较奇怪这边的 VS2005 视图菜单下面没有发现类视图项目。
打开的工程里面不显示类视图，不知道是不是环境设置的问题。

还好快捷键有效 ctrl+shift+C
可以通过快捷键打开类视图。

C++中实现字符串编码转换GBK转UTF8

2026-06-21T03:48:02+08:00

在C++中实现GBK和Utf8字符串的互转。
先定义字符串编码的codepage值。
#define CP_GBK 936
#define CP_UTF8 65001

Utf8字符串转GBK

[复制到剪贴板]




void Utf8Gbk(const CString& szUtf8, CString& szGbk)
{
    int buffLen = 0;
    int wlen = szUtf8.GetLength();

    WCHAR* wbuff = new WCHAR[wlen+1];

    MultiByteToWideChar(CP_UTF8, 0, szUtf8, -1, wbuff, wlen);

    buffLen = WideCharToMultiByte(CP_GBK, 0, wbuff, -1, NULL, 0, 0, 0);
    char* gbk = new char[buffLen+1];
    WideCharToMultiByte(CP_GBK, 0, wbuff, -1, (LPSTR)gbk, buffLen, 0, 0);

    delete[]wbuff;

    szGbk = gbk;

    delete[]gbk;    
}

GBK字符串转Utf8

[复制到剪贴板]




void GbkUtf8(const CString& szGbk, CString& szUtf8)
{
    int buffLen = 0;
    int wlen = szGbk.GetLength()*3;

    WCHAR* wbuff = new WCHAR[wlen+1];

    MultiByteToWideChar(CP_GBK, 0, szGbk, -1, wbuff, wlen);

    buffLen = WideCharToMultiByte(CP_UTF8, 0, wbuff, -1, NULL, 0, 0, 0);
    char* utf8 = new char[buffLen+1];
    WideCharToMultiByte(CP_UTF8, 0, wbuff, -1, (LPSTR)utf8, buffLen, 0, 0);

    delete[]wbuff;

    szUtf8 = utf8;

    delete[]utf8;    

}

权限提升代码

2026-06-21T03:48:02+08:00

提升当前的进程权限

void AdjustPrivilege(int pid, BOOL bEnable)
{
    HANDLE    hProcess;
  HANDLE    hToken=0;
    TOKEN_PRIVILEGES tkp;
  tkp.PrivilegeCount = 1;
  tkp.Privileges[0].Attributes = 0;
  if (bEnable)
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  if (LookupPrivilegeValue(NULL, "SeDebugPrivilege", &tkp.Privileges[0].Luid))
  {
    if (hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid))
    {
      if (OpenProcessToken(hProcess, TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &hToken))
      {
        if (AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, NULL, NULL))
        {
          CloseHandle(hToken);
        }
      }
      CloseHandle(hProcess);
    }
  }
}

防止注入的代码

2026-06-21T03:48:02+08:00

#define PROTECTED_DACL_SECURITY_INFORMATION (0x80000000L)

BOOL Lock_CurrentProcess()
{
  HANDLE hProcess = ::GetCurrentProcess();
  SID_IDENTIFIER_AUTHORITY sia = SECURITY_WORLD_SID_AUTHORITY;
  PSID pSid;
  BOOL bSus = FALSE;
  bSus = ::AllocateAndInitializeSid(&sia,1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,&pSid);
  if(!bSus) goto Cleanup;
  HANDLE hToken;
  bSus = ::OpenProcessToken(hProcess,TOKEN_QUERY,&hToken);
  if(!bSus) goto Cleanup;
  DWORD dwReturnLength;
  ::GetTokenInformation(hToken,TokenUser,NULL,NULL,&dwReturnLength);
  if(dwReturnLength > 0x400) goto Cleanup;
  LPVOID TokenInformation;
  TokenInformation = ::LocalAlloc(LPTR,0x400);//这里就引用SDK的函数不引用CRT的了
  DWORD dw;
  bSus = ::GetTokenInformation(hToken,TokenUser,TokenInformation,0x400,&dw);
  if(!bSus) goto Cleanup;
  PTOKEN_USER pTokenUser = (PTOKEN_USER)TokenInformation;
  BYTE Buf[0x200];
  PACL pAcl = (PACL)&Buf;
  bSus = ::InitializeAcl(pAcl,1024,ACL_REVISION);
  if(!bSus) goto Cleanup;
  bSus = ::AddAccessDeniedAce(pAcl,ACL_REVISION,0x000000FA,pSid);
  if(!bSus) goto Cleanup;
  bSus = ::AddAccessAllowedAce(pAcl,ACL_REVISION,0x00100701,pTokenUser->User.Sid);
  if(!bSus) goto Cleanup;
  if(::SetSecurityInfo(hProcess,SE_KERNEL_OBJECT,DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,NULL,NULL,pAcl,NULL) == 0)
    bSus = TRUE;
Cleanup:
  if(hProcess != NULL)
    ::CloseHandle(hProcess);
  if(pSid != NULL)
    ::FreeSid(pSid);
  return bSus;
}

这段代码就可以锁住其他进程打开本进程,当然也就防止了注入,和读写内存.

可以更绝点Denied ALL ACCESS(0xFFFFFFFF)就连结束都不可能了

::AllocateAndInitializeSid 可以换成 :: InitializeSid .因为我们并不需要初始化子Sid.
另外.
  bSus = ::AddAccessDeniedAce(pAcl,ACL_REVISION,0x000000FA,pSid);
  if(!bSus) goto Cleanup;
  bSus = ::AddAccessAllowedAce(pAcl,ACL_REVISION,0x00100701,pTokenUser->User.Sid);
实际上只需要下面的一句,或者干脆把它去掉,因为如果不添加Ace默认就是没有权限.既然这样上面的那句话AllocateAndInitializeSid 也可以省掉,也似乎有些多余

C++ 中 naked 函数调用

2026-06-21T03:48:02+08:00

正常的情况下，我们写一个 C/C++ 函数，即使是一个空函数，编译器也为我们做了不少的工作，生成了一些“必要”的代码。
请看下面的函数 (为了说明问题随便写的):

[复制到剪贴板]




int Test()
 { 
     int iReturn;
     char szTemp[33];
     
     szTemp[0] = 'A';
     szTemp[1] = '';
     iReturn = MessageBox(NULL, szTemp, szTemp, MB_OK);
     MessageBeep(iReturn);
     return iReturn;
  }

下面是用 VC6 在 Release 方式下编译后的的反汇编代码:

[复制到剪贴板]




00401000   sub         esp,24h     // 增加堆栈空间存放局部变量 (24H = 36D，4 字节对齐，注意这里没有为 iReturn 分配空间)
 00401003   push        esi         // 保存要使用的重要寄存器
 00401004   lea         eax,[esp+4] // 下面是传递 MessageBox() 要使用的参数
 00401008   push        0
 0040100A   lea         ecx,[esp+8] // 编译器愚蠢，根本不用 ECX，两个都是 szTemp，两次 PUSH EAX 不得了
 0040100E   push        eax
 0040100F   push        ecx
 00401010   push        0
 00401012   mov         byte ptr [esp+14h],41h
 00401017   mov         byte ptr [esp+15h],0
 0040101C   call        dword ptr ds:[40509Ch] // 调用 MessageBox()
 00401022   mov         esi,eax     // 保存返回值到变量 iReturn 。靠！变量 iReturn 自动使用 ESI，编译器太聪明了：）
 00401024   push        esi
 00401025   call        dword ptr ds:[4050A0h] // 调用 MessageBeep()
 0040102B   mov         eax,esi     // 把变量 iReturn 交给 EAX 作为返回值
 0040102D   pop         esi         // 恢复要使用的重要寄存器
 0040102E   add         esp,24h     // 减少堆栈空间
 00401031   ret                     // 堆栈长度减 4 并返回

这段代码虽然很精干 (都能自动使用寄存器来保存变量了)，但是有的时候我们并不需要编译器提供这些自作主张的代码 (比如写驱动程序的时候，不过我还没遇到过这种情况，呵呵~~)，我们希望整个全部函数都是自己亲手写进去的 (BT 呀^o^)。好，请出今天的主角 —— “naked”(怎么是裸体呀？)，
C++ 的扩展关键字 naked 允许我们完全定制一个函数，废话不说了，看例子 (熬夜写的 Zzzzzz~~):

[复制到剪贴板]



__declspec(naked) int Test()
 { 
     __asm
     { 
         SUB         ESP,24H
         PUSH        ESI
         LEA         EAX,[ESP+4]
         PUSH        0                      
         PUSH        EAX                    
         PUSH        EAX                    
         PUSH        0                      
         MOV         BYTE PTR [ESP+14H],41H 
         MOV         BYTE PTR [ESP+15H],0   
         CALL        DWORD PTR [MessageBoxA] 
         MOV         ESI,EAX
         PUSH        ESI                    
         CALL        DWORD PTR [MessageBeep] 
         MOV         EAX,ESI
         POP         ESI
         ADD         ESP,24H
         RET
      }
  }

上面的代码是使用的 VC 的内联汇编，和 VC 编译后生成的代码完全是一样的 (很有完全控制的成就感吧^_^)。上面我们并没有又节省什么 (节省的 PUSH ECX 并不是 naked 的功劳)，但是有的时候确实需要的 (举不出例子来了，倒！)。最后随便说说注意事项:

1.使用 naked 关键字需要自己构建 EBP 参数指针 (如果用到了 EBP 作为参数指针的话)；
2.必须自己使用 RET 或 RET n 指令返回 (除非你不返回)。

#pragma 指示符应用举例

2026-06-21T03:48:02+08:00

尽管 C 和 C++ 都已经有标准，但是几乎每个编译器 (广义，包含连接器等) 扩展一些 C/C++ 关键字。合理地应用这些关键字，有时候能使我们的工作非常方便。下面随便说说 Visual C++ 中 #pragma 指示符的使用。
一、用#pragma导出DLL函数

传统的到出 DLL 函数的方法是使用模块定义文件 (.def)，Visual C++ 提供了更简洁方便的方法，那就是“__declspec()”关键字后面跟“dllexport”，告诉连接去要导出这个函数，例如：

__declspec(dllexport) int __stdcall MyExportFunction(int iTest);

把“__declspec(dllexport)”放在函数声明的最前面，连接生成的 DLL 就会导出函数“_MyExportFunction@4”。

上面的导出函数的名称也许不是我的希望的，我们希望导出的是原版的“MyExportFunction”。还好，VC 提供了一个预处理指示符“#pragma”来指定连接选项 (不仅仅是这一个功能，还有很多指示功能) ，如下：

#pragma comment(linker,"/EXPORT:MyExportFunction=_MyExportFunction@4")

这下就天如人愿了：）。如果你想指定导出的顺序，或者只将函数导出为序号，没有 Entryname，这个预处理指示符 (确切地说是连接器) 都能够实现，看看 MSDN 的语法说明：

/EXPORT:entryname[,@ordinal[,NONAME]][,DATA]

@ordinal 指定顺序；NONAME 指定只将函数导出为序号；DATA 关键字指定导出项为数据项。

二、指示文件只包含一次

在头文件中，一般在整个工程中我们只要包含一次就够了，但是如果我在多个 .c/.cpp 文件中都要包含着个头文件，比如 Windows.h，那很多声明等等岂不是有两次了？解决这个问题的传统的方法是在头文件开始出用 #define 定义一个宏，比如 Windows.h 中:

#ifndef _WINDOWS_
#define _WINDOWS_

然后在文件结为加上 #endif，这样就可以避免被包含多次。但是这样的后果是代码的可读性较差 (个人观点)，VC 给我们提供了另外一个途径，那就是在文件的前面加上:

#pragma once

    是不是很方便？

三、使警告无效

    有时候我们不得不对变量进行强制转换，由此引来编译器的一番警告，特别是 C++ 中，类型检查相对于 C 更为严格。这虽然不影响什么，但是看起来多不爽——我是故意要这样的，你警告什么！：）这时候你看到警告类型，比如“warning C4311: “类型转换” : 从“HHOOK”到“BOOL”的指针截断”，在前面加上:

#pragma warning(disable: 4311)

   编译器就没话说了：）。

四、指定连接要使用的库

    比如我们连接的时候用到了 WSock32.lib，你当然可以不辞辛苦地把它加入到你的工程中。但是我觉得更方便的方法是使用 #pragma 指示符，指定要连接的库:

#pragma comment(lib, "WSock32.lib")

五、显示编译消息

     没多少用处，举个例子吧:

#ifdef _DEBUG
#pragma message("编译连接为调试模式...")
#endif // _DEBUG

Debug 和 Release 编译方式的本质区别

2026-06-21T03:48:02+08:00

Debug 通常称为调试版本，它包含调试信息，并且不作任何优化，便于程序员调试程序。Release 称为发布版本，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好地使用。
    Debug 和 Release 的真正秘密，在于一组编译选项。下面列出了分别针对二者的选项（当然除此之外还有其他一些，如/Fd /Fo，但区别并不重要，通常他们也不会引起 Release 版错误，在此不讨论）
Debug 版本
参数  含义
/MDd /MLd 或 /MTd 使用 Debug runtime library(调试版本的运行时刻函数库)
/Od 关闭优化开关
/D "_DEBUG" 相当于 #define _DEBUG,打开编译调试代码开关(主要针对assert函数)
/ZI 创建 Edit and continue(编辑继续)数据库，这样在调试过程中如果修改了源代码不需重新编译
/GZ 可以帮助捕获内存错误
/Gm 打开最小化重链接开关，减少链接时间
Release 版本
参数  含义
/MD /ML 或 /MT 使用发布版本的运行时刻函数库
/O1 或 /O2 优化开关，使程序最小或最快
/D "NDEBUG" 关闭条件编译调试代码开关(即不编译assert函数)
/GF 合并重复的字符串，并将字符串常量放到只读内存，防止被修改
    实际上，Debug 和 Release 并没有本质的界限，他们只是一组编译选项的集合，编译器只是按照预定的选项行动。事实上，我们甚至可以修改这些选项，从而得到优化过的调试版本或是带跟踪语句的发布版本。

哪些情况下 Release 版会出错
    有了上面的介绍，我们再来逐个对照这些选项看看 Release 版错误是怎样产生的
1.  Runtime Library：链接哪种运行时刻函数库通常只对程序的性能产生影响。调试版本的 Runtime Library 包含了调试信息，并采用了一些保护机制以帮助发现错误，因此性能不如发布版本。编译器提供的 Runtime Library 通常很稳定，不会造成 Release 版错误；倒是由于 Debug 的  Runtime Library 加强了对错误的检测，如堆内存分配，有时会出现 Debug 有错但 Release 正常的现象。应当指出的是，如果 Debug 有错，即使 Release 正常，程序肯定是有 Bug 的，只不过可能是 Release 版的某次运行没有表现出来而已。

2.  优化：这是造成错误的主要原因，因为关闭优化时源程序基本上是直接翻译的，而打开优化后编译器会作出一系列假设。这类错误主要有以下几种：
1.   帧指针(Frame Pointer)省略（简称 FPO ）：在函数调用过程中，所有调用信息（返回地址、参数）以及自动变量都是放在栈中的。若函数的声明与实现不同（参数、返回值、调用方式），就会产生错误????但 Debug 方式下，栈的访问通过 EBP 寄存器保存的地址实现，如果没有发生数组越界之类的错误（或是越界“不多”），函数通常能正常执行；Release 方式下，优化会省略 EBP 栈基址指针，这样通过一个全局指针访问栈就会造成返回地址错误是程序崩溃。C++ 的强类型特性能检查出大多数这样的错误，但如果用了强制类型转换，就不行了。你可以在 Release 版本中强制加入 /Oy- 编译选项来关掉帧指针省略，以确定是否此类错误。此类错误通常有：
•  MFC 消息响应函数书写错误。正确的应为：afx_msg LRESULT OnMessageOwn(WPARAM wparam, LPARAM lparam);
ON_MESSAGE 宏包含强制类型转换。防止这种错误的方法之一是重定义 ON_MESSAGE 宏，把下列代码加到 stdafx.h 中（在#include "afxwin.h"之后）,函数原形错误时编译会报错。#undef ON_MESSAGE
#define ON_MESSAGE(message, memberFxn) \
{ message, 0, 0, 0, AfxSig_lwl, \
(AFX_PMSG)(AFX_PMSGW)(static_cast< LRESULT (AFX_MSG_CALL \
CWnd::*)(WPARAM, LPARAM) > (&memberFxn) },

2.  volatile  型变量：volatile 告诉编译器该变量可能被程序之外的未知方式修改（如系统、其他进程和线程）。优化程序为了使程序性能提高，常把一些变量放在寄存器中（类似于 register 关键字），而其他进程只能对该变量所在的内存进行修改，而寄存器中的值没变。如果你的程序是多线程的，或者你发现某个变量的值与预期的不符而你确信已正确的设置了，则很可能遇到这样的问题。这种错误有时会表现为程序在最快优化出错而最小优化正常。把你认为可疑的变量加上  volatile 试试。

3.  变量优化：优化程序会根据变量的使用情况优化变量。例如，函数中有一个未被使用的变量，在  Debug 版中它有可能掩盖一个数组越界，而在 Release 版中，这个变量很可能被优化调，此时数组越界会破坏栈中有用的数据。当然，实际的情况会比这复杂得多。与此有关的错误有：
•   非法访问，包括数组越界、指针错误等。例如 void fn(void)
{
  int i;
  i = 1;
  int a[4];
  {
    int j;
    j = 1;
  }
  a[-1] = 1;//当然错误不会这么明显，例如下标是变量
  a[4] = 1;
}

j 虽然在数组越界时已出了作用域，但其空间并未收回，因而 i 和 j 就会掩盖越界。而 Release 版由于 i、j 并未其很大作用可能会被优化掉，从而使栈被破坏。

3.  _DEBUG 与 NDEBUG ：当定义了 _DEBUG 时，assert() 函数会被编译，而 NDEBUG 时不被编译。除此之外，VC++中还有一系列断言宏。这包括：
断言类型  定义
ANSI C 断言 void assert(int expression );
C Runtime Lib 断言 _ASSERT( booleanExpression );
_ASSERTE( booleanExpression );
MFC 断言 ASSERT( booleanExpression );
VERIFY( booleanExpression );
ASSERT_VALID( pObject );
ASSERT_KINDOF( classname, pobject );
ATL 断言 ATLASSERT( booleanExpression );
此外，TRACE() 宏的编译也受 _DEBUG 控制。
  所有这些断言都只在 Debug版中才被编译，而在 Release 版中被忽略。唯一的例外是 VERIFY() 。事实上，这些宏都是调用了  assert() 函数，只不过附加了一些与库有关的调试代码。如果你在这些宏中加入了任何程序代码，而不只是布尔表达式（例如赋值、能改变变量值的函数调用等），那么 Release 版都不会执行这些操作，从而造成错误。初学者很容易犯这类错误，查找的方法也很简单，因为这些宏都已在上面列出，只要利用 VC++ 的 Find in Files 功能在工程所有文件中找到用这些宏的地方再一一检查即可。另外，有些高手可能还会加入  #ifdef _DEBUG 之类的条件编译，也要注意一下。
顺便值得一提的是 VERIFY() 宏，这个宏允许你将程序代码放在布尔表达式里。这个宏通常用来检查 Windows API 的返回值。有些人可能为这个原因而滥用 VERIFY() ，事实上这是危险的，因为 VERIFY () 违反了断言的思想，不能使程序代码和调试代码完全分离，最终可能会带来很多麻烦。因此，专家们建议尽量少用这个宏。

4.  /GZ  选项：这个选项会做以下这些事： 1.  初始化内存和变量。包括用 0xCC 初始化所有自动变量，0xCD ( Cleared Data ) 初始化堆中分配的内存（即动态分配的内存，例如 new ），0xDD ( Dead Data ) 填充已被释放的堆内存（例如 delete ）， 0xFD( deFencde Data ) 初始化受保护的内存（debug 版在动态分配内存的前后加入保护内存以防止越界访问），其中括号中的词是微软建议的助记词。这样做的好处是这些值都很大，作为指针是不可能的（而且 32 位系统中指针很少是奇数值，在有些系统中奇数的指针会产生运行时错误），作为数值也很少遇到，而且这些值也很容易辨认，因此这很有利于在 Debug 版中发现 Release 版才会遇到的错误。要特别注意的是，很多人认为编译器会用 0 来初始化变量，这是错误的（而且这样很不利于查找错误）。

2.  通过函数指针调用函数时，会通过检查栈指针验证函数调用的匹配性。（防止原形不匹配）

3.  函数返回前检查栈指针，确认未被修改。（防止越界访问和原形不匹配，与第二项合在一起可大致模拟帧指针省略 FPO ）

通常 /GZ 选项会造成 Debug 版出错而 Release 版正常的现象，因为 Release 版中未初始化的变量是随机的，这有可能使指针指向一个有效地址而掩盖了非法访问。
除此之外，/Gm /GF 等选项造成错误的情况比较少，而且他们的效果显而易见，比较容易发现。

怎样“调试” Release 版的程序
    遇到 Debug 成功但 Release 失败，显然是一件很沮丧的事，而且往往无从下手。如果你看了以上的分析，结合错误的具体表现，很快找出了错误，固然很好。但如果一时找不出，以下给出了一些在这种情况下的策略。
1.   前面已经提过，Debug 和 Release 只是一组编译选项的差别，实际上并没有什么定义能区分二者。我们可以修改 Release 版的编译选项来缩小错误范围。如上所述，可以把 Release 的选项逐个改为与之相对的 Debug 选项，如 /MD 改为 /MDd、/O1 改为 /Od，或运行时间优化改为程序大小优化。注意，一次只改一个选项，看改哪个选项时错误消失，再对应该选项相关的错误，针对性地查找。这些选项在 Project \Settings... 中都可以直接通过列表选取，通常不要手动修改。由于以上的分析已相当全面，这个方法是最有效的。

2.  在编程过程中就要时常注意测试 Release 版本，以免最后代码太多，时间又很紧。

3.   在 Debug 版中使用 /W4 警告级别，这样可以从编译器获得最大限度的错误信息，比如 if( i =0 )就会引起 /W4 警告。不要忽略这些警告，通常这是你程序中的 Bug 引起的。但有时 /W4 会带来很多冗余信息，如未使用的函数参数警告，而很多消息处理函数都会忽略某些参数。我们可以用:#progma warning(disable: 4702) //禁止
//...
#progma warning(default: 4702) //重新允许来暂时禁止某个警告，或使用
#progma warning(push, 3) //设置警告级别为 /W3
//...
#progma warning(pop) //重设为 /W4

来暂时改变警告级别，有时你可以只在认为可疑的那一部分代码使用 /W4。

4.   你也可以像 Debug 一样调试你的 Release 版，只要加入调试符号。在 Project/Settings... 中，选中  Settings for "Win32 Release"，选中 C/C++ 标签，Category 选 General，Debug Info  选 Program Database。再在 Link 标签 Project options 最后加上 "/OPT:REF" (引号不要输)。这样调试器就能使用 pdb 文件中的调试符号。但调试时你会发现断点很难设置，变量也很难找到??这些都被优化过了。不过令人庆幸的是， Call Stack 窗口仍然工作正常，即使帧指针被优化，栈信息（特别是返回地址）仍然能找到。这对定位错误很有帮助。