皮皮网

1.Ebaz4205 Zynq7010 memcpy性能
2.VC++ MFC如何获取CPU ID及硬盘的序列号？
3.memcpy和memmove的区别
4.如何在C语言中嵌入汇编?汇编汇编
5.完整的C++库函数源代码哪里有下载?

Ebaz4205 Zynq7010 memcpy性能

       eba 板卡在Linux环境下的DDR测试结果显示，在SDK源码环境NonOS中进行ZYNQ pdk自带的源码memcpy性能测试。

       针对ZYNQ测量时间代码，汇编汇编通过获取全局定时器的源码时间值，基准为系统主频二分频。汇编汇编

       定义COUNTS_PER_SECOND，源码jquery源码难么表示每秒计数值（基于CPU频率除以2）。汇编汇编

       在测试中添加内存拷贝代码，源码使用MB大小进行操作。汇编汇编

       经过计算，源码得出memcpy的汇编汇编运行速度。

       通过反汇编ELF代码，源码可以进一步分析和理解memcpy的汇编汇编具体执行过程和性能表现。

VC++ MFC如何获取CPU ID及硬盘的序列号？

       // “获得Intel CPU ID”按钮消息处理函数

       void CIntelCPUIDDlg::OnBtnCPUID()

       {

        unsigned long s1,源码s2;

        unsigned char vendor_id[]="------------";//CPU提供商ID

        CString str1,str2,str3;

        // 以下为获得CPU ID的汇编语言指令

        _asm // 得到CPU提供商信息

        {

        xor eax,eax // 将eax清0

        cpuid // 获取CPUID的指令

        mov dword ptr vendor_id,ebx

        mov dword ptr vendor_id[+4],edx

        mov dword ptr vendor_id[+8],ecx

        }

        str1.Format("%s",vendor_id);

        _asm // 得到CPU ID的高位

        {

        mov eax,h

        xor edx,edx

        cpuid

        mov s2,eax

        }

        str2.Format("%X-",s2);

        _asm // 得到CPU ID的低位

        {

        mov eax,h

        xor ecx,ecx

        xor edx,edx

        cpuid

        mov s1,edx

        mov s2,ecx

        }

        str3.Format("%X-%X\n",s1,s2);

        str2=str2+str3;

        m_editVendor.SetWindowText(str1);

        m_editCPUID.SetWindowText(str2);

       }

       // GetHDSerial.cpp: implementation of the CGetHDSerial class.

       //

       //////////////////////////////////////////////////////////////////////

       #include "stdafx.h"

       #include "GetHDSerial.h"

       char m_buffer[];

       WORD m_serial[];

       DWORD m_OldInterruptAddress;

       DWORDLONG m_IDTR;

       // 等待硬盘空闲

       static unsigned int WaitHardDiskIdle()

       {

        BYTE byTemp;

       Waiting:

        _asm

        {

        mov dx, 0x1f7

        in al, dx

        cmp al, 0x

        jb Endwaiting

        jmp Waiting

        }

       Endwaiting:

        _asm

        {

        mov byTemp, al

        }

        return byTemp;

       }

       //中断服务程序

       void _declspec( naked )InterruptProcess(void)

       {

        int byTemp;

        int i;

        WORD temp;

        //保存寄存器值

        _asm

        {

        push eax

        push ebx

        push ecx

        push edx

        push esi

        }

        WaitHardDiskIdle();//等待硬盘空闲状态

        _asm

        {

        mov dx, 0x1f6

        mov al, 0xa0

        out dx, al

        }

        byTemp = WaitHardDiskIdle(); //若直接在Ring3级执行等待命令，会进入死循环

        if ((byTemp&0x)!=0x)

        {

        _asm // 恢复中断现场并退出中断服务程序

        {

        pop esi

        pop edx

        pop ecx

        pop ebx

        pop eax

        iretd

        }

        }

        _asm

        {

        mov dx, 0x1f6 //命令端口1f6,选择驱动器0

        mov al, 0xa0

        out dx, al

        inc dx

        mov al, 0xec

        out dx, al //发送读驱动器参数命令

        }

        byTemp = WaitHardDiskIdle();

        if ((byTemp&0x)!=0x)

        {

        _asm // 恢复中断现场并退出中断服务程序

        {

        pop esi

        pop edx

        pop ecx

        pop ebx

        pop eax

        iretd

        }

        }

        //读取硬盘控制器的全部信息

        for (i=0;i<;i++)

        {

        _asm

        {

        mov dx, 0x1f0

        in ax, dx

        mov temp, ax

        }

        m_serial[i] = temp;

        }

        _asm

        {

        pop esi

        pop edx

        pop ecx

        pop ebx

        pop eax

        iretd

        }

       }

       //////////////////////////////////////////////////////////////////////

       // Construction/Destruction

       //////////////////////////////////////////////////////////////////////

       CGetHDSerial::CGetHDSerial()

       {

       }

       CGetHDSerial::~CGetHDSerial()

       {

       }

       // 读取硬盘序列号函数

       char* CGetHDSerial::GetHDSerial()

       {

        m_buffer[0]='\n';

        // 得到当前操作系统版本

        OSVERSIONINFO OSVersionInfo;

        OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

        GetVersionEx( &OSVersionInfo);

        if (OSVersionInfo.dwPlatformId != VER_PLATFORM_WIN_NT)

        {

        // Windows 9x/ME下读取硬盘序列号

        WORD m_wWin9xHDSerial[];

        Win9xReadHDSerial(m_wWin9xHDSerial);

        strcpy (m_buffer, WORDToChar (m_wWin9xHDSerial, , ));

        }

        else

        {

        // Windows NT//XP下读取硬盘序列号

        DWORD m_wWinNTHDSerial[];

        // 判断是否有SCSI硬盘

        if ( ! WinNTReadIDEHDSerial(m_wWinNTHDSerial))

        WinNTReadSCSIHDSerial(m_wWinNTHDSerial);

        strcpy (m_buffer, DWORDToChar (m_wWinNTHDSerial, , ));

        }

        return m_buffer;

       }

       // Windows9X/ME系统下读取硬盘序列号

       void _stdcall CGetHDSerial::Win9xReadHDSerial(WORD * buffer)

       {

        int i;

        for(i=0;i<;i++)

        buffer[i]=0;

        _asm

        {

        push eax

        //获取修改的中断的中断描述符（中断门）地址

        sidt m_IDTR

        mov eax,dword ptr [m_IDTR+h]

        add eax,3*h+h

        cli

        //保存原先的中断入口地址

        push ecx

        mov ecx,dword ptr [eax]

        mov cx,word ptr [eax-h]

        mov dword ptr m_OldInterruptAddress,ecx

        pop ecx

        //设置修改的中断入口地址为新的中断处理程序入口地址

        push ebx

        lea ebx,InterruptProcess

        mov word ptr [eax-h],bx

        shr ebx,h

        mov word ptr [eax+h],bx

        pop ebx

        //执行中断，转到Ring 0（类似CIH病毒原理）

        int 3h

        //恢复原先的中断入口地址

        push ecx

        mov ecx,dword ptr m_OldInterruptAddress

        mov word ptr [eax-h],cx

        shr ecx,h

        mov word ptr [eax+h],cx

        pop ecx

        sti

        pop eax

        }

        for(i=0;i<;i++)

        buffer[i]=m_serial[i];

       }

       // Windows 9x/ME系统下，将字类型（WORD）的硬盘信息转换为字符类型（char）

       char * CGetHDSerial::WORDToChar (WORD diskdata [], int firstIndex, int lastIndex)

       {

        static char string [];

        int index = 0;

        int position = 0;

        // 按照高字节在前，低字节在后的顺序将字数组diskdata 中内容存入到字符串string中

        for (index = firstIndex; index <= lastIndex; index++)

        {

        // 存入字中的高字节

        string [position] = (char) (diskdata [index] / );

        position++;

        // 存入字中的低字节

        string [position] = (char) (diskdata [index] % );

        position++;

        }

        // 添加字符串结束标志

        string [position] = '\0';

        // 删除字符串中空格

        for (index = position - 1; index > 0 && ' ' == string [index]; index--)

        string [index] = '\0';

        return string;

       }

       // Windows NT//XP系统下，将双字类型（DWORD）的硬盘信息转换为字符类型（char）

       char* CGetHDSerial::DWORDToChar (DWORD diskdata [], int firstIndex, int lastIndex)

       {

        static char string [];

        int index = 0;

        int position = 0;

        // 按照高字节在前，低字节在后的顺序将双字中的低字存入到字符串string中

        for (index = firstIndex; index <= lastIndex; index++)

        {

        // 存入低字中的高字节

        string [position] = (char) (diskdata [index] / );

        position++;

        // 存入低字中的低字节

        string [position] = (char) (diskdata [index] % );

        position++;

        }

        // 添加字符串结束标志

        string [position] = '\0';

        // 删除字符串中空格

        for (index = position - 1; index > 0 && ' ' == string [index]; index--)

        string [index] = '\0';

        return string;

       }

       // Windows NT//XP下读取IDE硬盘序列号

       BOOL CGetHDSerial::WinNTReadIDEHDSerial(DWORD * buffer)

       {

        BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

        BOOL bFlag = FALSE;

        int drive = 0;

        char driveName [];

        HANDLE hPhysicalDriveIOCTL = 0;

        sprintf (driveName, "\\\\.\\PhysicalDrive%d", drive);

        // Windows NT//XP下创建文件需要管理员权限

        hPhysicalDriveIOCTL = CreateFile (driveName,

        GENERIC_READ | GENERIC_WRITE,

        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,

        OPEN_EXISTING, 0, NULL);

        if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)

        {

        GETVERSIONOUTPARAMS VersionParams;

        DWORD cbBytesReturned = 0;

        // 得到驱动器的IO控制器版本

        memset ((void*) &VersionParams, 0, sizeof(VersionParams));

        if(DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_GET_VERSION,

        NULL, 0, &VersionParams,

        sizeof(VersionParams),

        &cbBytesReturned, NULL) )

        {

        if (VersionParams.bIDEDeviceMap > 0)

        {

        BYTE bIDCmd = 0; // IDE或者ATAPI识别命令

        SENDCMDINPARAMS scip;

        // 如果驱动器是光驱，采用命令IDE_ATAPI_IDENTIFY， command,

        // 否则采用命令IDE_ATA_IDENTIFY读取驱动器信息

        bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x)?

        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;

        memset (&scip, 0, sizeof(scip));

        memset (IdOutCmd, 0, sizeof(IdOutCmd));

        // 获取驱动器信息

        if (WinNTGetIDEHDInfo (hPhysicalDriveIOCTL,

        &scip,

        (PSENDCMDOUTPARAMS)&IdOutCmd,

        (BYTE) bIDCmd,

        (BYTE) drive,

        &cbBytesReturned))

        {

        int m = 0;

        USHORT *pIdSector = (USHORT *)

        ((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer;

        for (m = 0; m < ; m++)

        buffer[m] = pIdSector [m];

        bFlag = TRUE; // 读取硬盘信息成功

        }

        }

        }

        CloseHandle (hPhysicalDriveIOCTL); // 关闭句柄

        }

        return bFlag;

       }

       // WindowsNT//XP系统下读取SCSI硬盘序列号

       BOOL CGetHDSerial::WinNTReadSCSIHDSerial (DWORD * buffer)

       {

        buffer[0]='\n';

        int controller = 0;

        HANDLE hScsiDriveIOCTL = 0;

        char driveName [];

        sprintf (driveName, "\\\\.\\Scsi%d:", controller);

        // Windows NT//XP下任何权限都可以进行

        hScsiDriveIOCTL = CreateFile (driveName,

        GENERIC_READ | GENERIC_WRITE,

        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,

        OPEN_EXISTING, 0, NULL);

        if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE)

        {

        int drive = 0;

        DWORD dummy;

        for (drive = 0; drive < 2; drive++)

        {

        char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH];

        SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer;

        SENDCMDINPARAMS *pin =

        (SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));

        // 准备参数

        memset (buffer, 0, sizeof (buffer));

        p -> HeaderLength = sizeof (SRB_IO_CONTROL);

        p -> Timeout = ;

        p -> Length = SENDIDLENGTH;

        p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;

        strncpy ((char *) p -> Signature, "SCSIDISK", 8);

        pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;

        pin -> bDriveNumber = drive;

        // 得到SCSI硬盘信息

        if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,

        buffer,

        sizeof (SRB_IO_CONTROL) +

        sizeof (SENDCMDINPARAMS) - 1,

        buffer,

        sizeof (SRB_IO_CONTROL) + SENDIDLENGTH,

        &dummy, NULL))

        {

        SENDCMDOUTPARAMS *pOut =

        (SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));

        IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer);

        if (pId -> sModelNumber [0])

        {

        int n = 0;

        USHORT *pIdSector = (USHORT *) pId;

        for (n = 0; n < ; n++)

        buffer[n] =pIdSector [n];

        return TRUE; // 读取成功

        }

        }

        }

        CloseHandle (hScsiDriveIOCTL); // 关闭句柄

        }

        return FALSE; // 读取失败

       }

       // Windows NT//XP下读取IDE设备信息

       BOOL CGetHDSerial::WinNTGetIDEHDInfo (HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,

        PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,

        PDWORD lpcbBytesReturned)

       {

        // 为读取设备信息准备参数

        pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;

        pSCIP -> irDriveRegs.bFeaturesReg = 0;

        pSCIP -> irDriveRegs.bSectorCountReg = 1;

        pSCIP -> irDriveRegs.bSectorNumberReg = 1;

        pSCIP -> irDriveRegs.bCylLowReg = 0;

        pSCIP -> irDriveRegs.bCylHighReg = 0;

        // 计算驱动器位置

        pSCIP -> irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4);

        // 设置读取命令

        pSCIP -> irDriveRegs.bCommandReg = bIDCmd;

        pSCIP -> bDriveNumber = bDriveNum;

        pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;

        // 读取驱动器信息

        return ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_GET_DRIVE_INFO,

        (LPVOID) pSCIP,

        sizeof(SENDCMDINPARAMS) - 1,

        (LPVOID) pSCOP,

        sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,

        lpcbBytesReturned, NULL) );

       }

memcpy和memmove的区别

       memcpy和memmove（）都是C语言中的库函数，在头文件string.h中，作用是拷贝一定长度的内存的内容，原型分别如下：

       void *memcpy(void *dst, const void *src, size_t count);

       void *memmove(void *dst, const void *src, size_t count);

       ä»–们的作用是一样的，唯一的区别是，当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确。

       äºŒè€…çš„c语言实现很简单，有兴趣的朋友可以去看看。在实际情况下，这两个函数都是用汇编实现的。

       memmove在copy两个有重叠区域的内存时可以保证copy的正确，而memcopy就不行了，但memcopy比memmove的速度要快一些，如：

       char s[] = "";

       char* p1 = s;

       char* p2 = s+2;

       memcpy(p2, p1, 5)与memmove(p2, p1, 5)的结果就可能是不同的，memmove()可以将p1的头5个字符""正确拷贝至p2，而memcpy()的结果就不一定正确了.

       å’Œmemcpy相比，src和des有重叠的情况下，memmove可以保证数据的完整性.

       memmove保证的原因很简单，就是针对重叠的情况做特殊处理，因此速度会比memcpy慢一些

       å…·ä½“的算法并不难想，画个图，分两种情况

       1. src的尾部和des的头部重合

        从src尾部开始，以地址 -- 的方式copy到des

       2. src的头部和des的尾部重合

        从src头部开始，以地址 ++ 的方式copy到des

如何在C语言中嵌入汇编?

       在 Visual C++ 中使用内联汇编- -

       使用内联汇编可以在 C/C++ 代码中嵌入汇编语言指令，而且不需要额外的汇编汇编汇编和连接步骤。在 Visual C++ 中，内联汇编是内置的编译器，因此不需要配置诸如 MASM 一类的独立汇编工具。这里，我们就以 Visual Studio .NET 为背景，介绍在 Visual C++ 中使用内联汇的相关知识（如果是早期的版本，可能会有些许出入）。

        内联汇编代码可以使用 C/C++ 变量和函数，因此它能非常容易地整合到 C/C++ 代码中。它能做一些对于单独使用 C/C++ 来说非常笨重或不可能完成的任务。

       一、 优点

        使用内联汇编可以在 C/C++ 代码中嵌入汇编语言指令，而且不需要额外的汇编和连接步骤。在 Visual C++ 中，内联汇编是大渝网源码内置的编译器，因此不需要配置诸如 MASM 一类的独立汇编工具。这里，我们就以 Visual Studio .NET 为背景，介绍在 Visual C++ 中使用内联汇的相关知识（如果是早期的版本，可能会有些许出入）。

        内联汇编代码可以使用 C/C++ 变量和函数，因此它能非常容易地整合到 C/C++ 代码中。它能做一些对于单独使用 C/C++ 来说非常笨重或不可能完成的任务。

        内联汇编的用途包括：

       使用汇编语言编写特定的函数；

       编写对速度要求非常较高的代码；

       在设备驱动程序中直接访问硬件；

       编写 naked 函数的初始化和结束代码。

       二、 关键字

        使用内联汇编要用到 __asm 关键字，它可以出现在任何允许 C/C++ 语句出现的地方。我们来看一些例子：

       简单的 __asm 块：

        __asm

        {

        MOV AL, 2

        MOV DX, 0xD

        OUT AL, DX

        }

       在每条汇编指令之前加 __asm 关键字：

        __asm MOV AL, 2

        __asm MOV DX, 0xD

        __asm OUT AL, DX

       因为 __asm 关键字是语句分隔符，所以可以把多条汇编指令放在同一行：

        __asm MOV AL, 2 __asm MOV DX, 0xD __asm OUT AL, DX

        显然，第一种方法与 C/C++ 的风格很一致，并且把汇编代码和 C/C++ 代码清楚地分开，还避免了重复输入 __asm 关键字，因此推荐使用第一种方法。

        不像在 C/C++ 中的"{ }"，__asm 块的"{ }"不会影响 C/C++ 变量的作用范围。同时，__asm 块可以嵌套，而且嵌套也不会影响变量的作用范围。

        为了与低版本的 Visual C++ 兼容，_asm 和 __asm 具有相同的意义。另外，Visual C++ 支持标准 C++ 的 asm 关键字，但是它不会生成任何指令，它的莎莎源码质量作用仅限于使编译器不会出现编译错误。要使用内联汇编，必须使用 __asm 而不是 asm 关键字。

       三、 汇编语言

       1. 指令集

        内联汇编支持 Intel Pentium 4 和 AMD Athlon 的所有指令。更多其它处理器的指令可以通过 _EMIT 伪指令来创建（_EMIT 伪指令说明见下文）。

       2. MASM 表达式

        在内联汇编代码中，可以使用所有的 MASM 表达式（MASM 表达式是指用来计算一个数值或一个地址的操作符和操作数的组合）。

       3. 数据指示符和操作符

        虽然 __asm 块中允许使用 C/C++ 的数据类型和对象，但它不能使用 MASM 指示符和操作符来定义数据对象。这里特别指出，__asm 块中不允许 MASM 中的定义指示符（DB、DW、DD、DQ、DT 和 DF），也不允许使用 DUP 和 THIS 操作符。MASM 中的结构和记录也不再有效，内联汇编不接受 STRUC、RECORD、WIDTH 或者 MASK。

       4. EVEN 和 ALIGN 指示符

        尽管内联汇编不支持大多数 MASM 指示符，但它支持 EVEN 和 ALIGN。当需要的时候，这些指示符在汇编代码里面加入 NOP 指令（空操作）使标号对齐到特定边界。这样可以使某些处理器取指令时具有更高的效率。

       5. MASM 宏指示符

        内联汇编不是宏汇编，不能使用 MASM 宏指示符（MACRO、REPT、IRC、斗驴视频源码IRP 和 ENDM）和宏操作符（<>、!、&、% 和 .TYPE）。

       6. 段

        必须使用寄存器而不是名称来指明段（段名称"_TEXT"是无效的）。并且，段跨越必须显式地说明，如 ES:[EBX]。

       7. 类型和变量大小

        在内联汇编中，可以用 LENGTH、SIZE 和 TYPE 来获取 C/C++ 变量和类型的大大小。

        * LENGTH 操作符用来取得 C/C++ 中数组的元素个数（如果不是一个数组，则结果为 1）。

        * SIZE 操作符可以获取 C/C++ 变量的大小（一个变量的大小是 LENGTH 和 TYPE 的乘积）。

        * TYPE 操作符可以返回 C/C++ 类型和变量的大小（如果变量是一个数组，它得到的是数组中单个元素的大小）。

        例如，程序中定义了一个 8 维的整数型变量：

        int iArray[8];

        下面是 C 和汇编表达式中得到的 iArray 及其元素的相关值：

        __asm C Size

        LENGTH iArray sizeof(iArray)/sizeof(iArray[0]) 8

        SIZE iArray sizeof(iArray)

        TYPE iArray sizeof(iArray[0]) 4

       8. 注释

        内联汇编中可以使用汇编语言的注释，即";"。例如：

        __asm MOV EAX, OFFSET pbBuff ; Load address of pbBuff

        因为 C/C++ 宏将会展开到一个逻辑行中，为了避免在宏中使用汇编语言注释带来的混乱，内联汇编也允许使用 C/C++ 风格的注释。

       9. _EMIT 伪指令

        _EMIT 伪指令相当于 MASM 中的 DB，但是 _EMIT 一次只能在当前代码段（.text 段）中定义一个字节。例如：

        __asm

        {

        JMP _CodeLabel

        _EMIT 0x ; 定义混合在代码段的数据

        _EMIT 0x

        _CodeLabel: ; 这里是代码

        _EMIT 0x ; NOP指令

        }

       . 寄存器使用

        一般来说，不能假定某个寄存器在 __asm 块开始的时候有已知的值。寄存器的值将不能保证会从 __asm 块保留到另外一个 __asm 块中。

        如果一个函数声明为 __fastcall 调用方式，则其参数将通过寄存器而不是七米网源码堆栈来传递。这将会使 __asm 块产生问题，因为函数无法被告知哪个参数在哪个寄存器中。如果函数接收了 EAX 中的参数并立即储存一个值到 EAX 中的话，原来的参数将丢失掉。另外，在所有声明为 __fastcall 的函数中，ECX 寄存器是必须一直保留的。为了避免以上的冲突，包含 __asm 块的函数不要声明为 __fastcall 调用方式。

       提示：如果使用 EAX、EBX、ECX、EDX、ESI 和 EDI 寄存器，你不需要保存它。但如果你用到了 DS、SS、SP、BP 和标志寄存器，那就应该用 PUSH 保存这些寄存器。

       提示：如果程序中改变了用于 STD 和 CLD 的方向标志，必须将其恢复到原来的值。

       四、 使用 C/C++ 元素

       1. 可用的 C/C++ 元素

        C/C++ 与汇编语言可以混合使用，在内联汇编中可以使用 C/C++ 变量以及很多其它的 C/C++ 元素，包括：

       符号，包括标号、变量和函数名；

       常量，包括符号常量和枚举型成员；

       宏定义和预处理指示符；

       注释，包括"/**/"和"//"；

       类型名，包括所有 MASM 中合法的类型；

       typedef 名称，通常使用 PTR 和 TYPE 操作符，或者使用指定的的结构或枚举成员。

        在内联汇编中，可以使用 C/C++ 或汇编语言的基数计数法。例如，0x 和 H 是相等的。

       2. 操作符使用

        内联汇编中不能使用诸如"<<"一类的 C/C++ 操作符。但是，C/C++ 和 MASM 共有的操作符（比如"*"和"[]"操作符），都被认为是汇编语言的操作符，是可以使用的。举个例子：

        int iArray[];

        __asm MOV iArray[6], BX ; Store BX at iArray + 6 (Not scaled)

        iArray[6] = 0; // Store 0 at iArray+ (Scaled)

       提示：在内联汇编中，可以使用 TYPE 操作符使其与 C/C++ 一致。比如，下面两条语句是一样的：

        __asm MOV iArray[6 * TYPE int], 0 ; Store 0 at iArray +

        iArray[6] = 0; // Store 0 at iArray +

       3. C/C++ 符号使用

        在 __asm 块中可以引用所有在作用范围内的 C/C++ 符号，包括变量名称、函数名称和标号。但是不能访问 C++ 类的成员函数。

        下面是在内联汇编中使用 C/C++ 符号的一些限制：

       每条汇编语句只能包含一个 C/C++ 符号。在一条汇编指令中，多个符号只能出现在 LENGTH、TYPE 或 SIZE 表达式中。

       在 __asm 块中引用函数必须先声明。否则，编译器将不能区别 __asm 块中的函数名和标号。

       在 __asm 块中不能使用对于 MASM 来说是保留字的 C/C++ 符号（不区分大小写）。MASM 保留字包含指令名称（如 PUSH）和寄存器名称（如 ESI）等。

       在 __asm 块中不能识别结构和联合标签。

       4. 访问 C/C++ 中的数据

        内联汇编的一个非常大的方便之处是它可以使用名称来引用 C/C++ 变量。例如，如果 C/C++ 变量 iVar 在作用范围内：

        __asm MOV EAX, iVar ; Stores the value of iVar in EAX

        如果 C/C++ 中的类、结构或者枚举成员具有唯一的名称，则在 __asm 块中可以只通过成员名称来访问（省略"."操作符之前的变量名或 typedef 名称）。然而，如果成员不是唯一的，你必须在"."操作符之前加上变量名或 typedef 名称。例如，下面的两个结构都具有 SameName 这个成员变量：

        struct FIRST_TYPE

        {

        char *pszWeasel;

        int SameName;

        };

        struct SECOND_TYPE

        {

        int iWonton;

        long SameName;

        };

        如果按下面方式声明变量：

        struct FIRST_TYPE ftTest;

        struct SECOND_TYPE stTemp;

        那么，所有引用 SameName 成员的地方都必须使用变量名，因为 SameName 不是唯一的。另外，由于上面的 pszWeasel 变量具有唯一的名称，你可以仅仅使用它的成员名称来引用它：

        __asm

        {

        MOV EBX, OFFSET ftTest

        MOV ECX, [EBX]ftTest.SameName ; 必须使用"ftTest"

        MOV ESI, [EBX]. pszWeasel ; 可以省略"ftTest"

        }

       提示：省略变量名仅仅是为了书写代码方便，生成的汇编指令还是一样的。

       5. 用内联汇编写函数

        如果用内联汇编写函数的话，要传递参数和返回一个值都是非常容易的。看下面的例子，比较一下用独立汇编和内联汇编写的函数：

        ; PowerAsm.asm

        ; Compute the power of an integer

        PUBLIC GetPowerAsm

        _TEXT SEGMENT WORD PUBLIC 'CODE'

        GetPowerAsm PROC

        PUSH EBP ; Save EBP

        MOV EBP, ESP ; Move ESP into EBP so we can refer

        ; to arguments on the stack

        MOV EAX, [EBP+4] ; Get first argument

        MOV ECX, [EBP+6] ; Get second argument

        SHL EAX, CL ; EAX = EAX * (2 ^ CL)

        POP EBP ; Restore EBP

        RET ; Return with sum in EAX

        GetPowerAsm ENDP

        _TEXT ENDS

        END

        C/C++ 函数一般用堆栈来传递参数，所以上面的函数中需要通过堆栈位置来访问它的参数（在 MASM 或其它一些汇编工具中，也允许通过名称来访问堆栈参数和局部堆栈变量）。

        下面的程序是使用内联汇编写的：

        // PowerC.c

        #include

        int GetPowerC(int iNum, int iPower);

        int main()

        {

        printf("3 times 2 to the power of 5 is %d\n", GetPowerC( 3, 5));

        }

        int GetPowerC(int iNum, int iPower)

        {

        __asm

        {

        MOV EAX, iNum ; Get first argument

        MOV ECX, iPower ; Get second argument

        SHL EAX, CL ; EAX = EAX * (2 to the power of CL)

        }

        // Return with result in EAX

        }

        使用内联汇编写的 GetPowerC 函数可以通过参数名称来引用它的参数。由于 GetPowerC 函数没有执行 C 的 return 语句，所以编译器会给出一个警告信息，我们可以通过 #pragma warning 禁止生成这个警告。

        内联汇编的其中一个用途是编写 naked 函数的初始化和结束代码。对于一般的函数，编译器会自动帮我们生成函数的初始化（构建参数指针和分配局部变量等）和结束代码（平衡堆栈和返回一个值等）。使用内联汇编，我们可以自己编写干干净净的函数。当然，此时我们必须自己动手做一些有关函数初始化和扫尾的工作。例如：

        void __declspec(naked) MyNakedFunction()

        {

        // Naked functions must provide their own prolog.

        __asm

        {

        PUSH EBP

        MOV ESP, EBP

        SUB ESP, __LOCAL_SIZE

        }

        .

        .

        .

        // And we must provide epilog.

        __asm

        {

        POP EBP

        RET

        }

        }

       6. 调用 C/C++ 函数

        内联汇编中调用声明为 __cdecl 方式（默认）的 C/C++ 函数必须由调用者清除参数堆栈，下面是一个调用 C/C++ 函数例子:

        #include

        char szFormat[] = "%s %s\n";

        char szHello[] = "Hello";

        char szWorld[] = " world";

        void main()

        {

        __asm

        {

        MOV EAX, OFFSET szWorld

        PUSH EAX

        MOV EAX, OFFSET szHello

        PUSH EAX

        MOV EAX, OFFSET szFormat

        PUSH EAX

        CALL printf

        // 压入了 3 个参数在堆栈中，调用函数之后要调整堆栈

        ADD ESP,

        }

        }

       提示：参数是按从右往左的顺序压入堆栈的。

        如果调用 __stdcall 方式的函数，则不需要自己清除堆栈。因为这种函数的返回指令是 RET n，会自动清除堆栈。大多数 Windows API 函数均为 __stdcall 调用方式（仅除 wsprintf 等几个之外），下面是一个调用 MessageBox 函数的例子：

        #include

        TCHAR g_tszAppName[] = TEXT("API Test");

        void main()

        {

        TCHAR tszHello[] = TEXT("Hello, world!");

        __asm

        {

        PUSH MB_OK OR MB_ICONINFORMATION

        PUSH OFFSET g_tszAppName ; 全局变量用 OFFSET

        LEA EAX, tszHello ; 局部变量用 LEA

        PUSH EAX

        PUSH 0

        CALL DWORD PTR [MessageBox] ; 注意这里不是 CALL MessageBox，而是调用重定位过的函数地址

        }

        }

       提示：可以不受限制地访问 C++ 成员变量，但是不能访问 C++ 的成员函数。

       7. 定义 __asm 块为 C/C++ 宏

        使用 C/C++ 宏可以方便地把汇编代码插入到源代码中。但是这其中需要额外地注意，因为宏将会扩展到一个逻辑行中。

       为了不会出现问题，请按以下规则编写宏：

       使用花括号把 __asm 块包围住；

       把 __asm 关键字放在每条汇编指令之前；

       使用经典 C 风格的注释（"/* comment */"）,不要使用汇编风格的注释（"; comment"）或单行的 C/C++ 注释（"// comment"）；

        举个例子，下面定义了一个简单的宏：

        #define PORTIO __asm \

        /* Port output */ \

        { \

        __asm MOV AL, 2 \

        __asm MOV DX, 0xD \

        __asm OUT DX, AL \

        }

        乍一看来，后面的三个 __asm 关键字好像是多余的。其实它们是需要的，因为宏将被扩展到一个单行中：

        __asm /* Port output */ { __asm MOV AL, 2 __asm MOV DX, 0xD __asm OUT DX, AL }

        从扩展后的代码中可以看出，第三个和第四个 __asm 关键字是必须的（作为语句分隔符）。在 __asm 块中，只有 __asm 关键字和换行符会被认为是语句分隔符，又因为定义为宏的一个语句块会被认为是一个逻辑行，所以必须在每条指令之前使用 __asm 关键字。

        括号也是需要的，如果省略了它，编译器将不知道汇编代码在哪里结束，__asm 块后面的 C/C++ 语句看起来会被认为是汇编指令。

        同样是由于宏展开的原因，汇编风格的注释（"; comment"）和单行的 C/C++ 注释（"// commen"）也可能会出现错误。为了避免这些错误，在定义 __asm 块为宏时请使用经典 C 风格的注释（"/* comment */"）。

        和 C/C++ 宏一样 __asm 块写的宏也可以拥有参数。和 C/C++ 宏不一样的是，__asm 宏不能返回一个值，因此，不能使用这种宏作为 C/C++ 表达式。

        不要不加选择地调用这种类型的宏。比如，在声明为 __fastcall 的函数中调用汇编语言宏可能会导致不可预料的结果（请参看前文的说明）。

       8. 转跳

        可以在 C/C++ 里面使用 goto 转跳到 __asm 块中的标号处，也可以在 __asm 块中转跳到 __asm 块里面或外面的标号处。__asm 块内的标号是不区分大小写的（指令、指示符等也是不区分大小写的）。例如：

        void MyFunction()

        {

        goto C_Dest; /* 正确 */

        goto c_dest; /* 错误 */

        goto A_Dest; /* 正确 */

        goto a_dest; /* 正确 */

        __asm

        {

        JMP C_Dest ; 正确

        JMP c_dest ; 错误

        JMP A_Dest ; 正确

        JMP a_dest ; 正确

        a_dest: ; __asm 标号

        }

        C_Dest: /* C/C++ 标号 */

        return;

        }

        不要使用函数名称当作标号，否则将转跳到函数中执行，而不是标号处。例如，由于 exit 是 C/C++ 的函数，下面的转跳将不会到 exit 标号处：

        ; 错误：使用函数名作为标号

        JNE exit

        .

        .

        .

        exit:

        .

        .

        .

        美元符号"$"用于指定当前指令位置，常用于条件跳转中，例如：

        JNE $+5 ; 下面这条指令的长度是 5 个字节

        JMP _Label

        NOP ; $+5，转跳到了这里

        .

        .

        .

        _Label:

        .

        .

        .

       五、在 Visual C++ 工程中使用独立汇编

        内联汇编代码不易于移植，如果你的程序打算在不同类型的机器（比如 x 和 Alpha）上运行，你可能需要在不同的模块中使用特定的机器代码。这时候你可以使用 MASM（Microsoft Macro Assembler），因为 MASM 支持更多方便的宏指令和数据指示符。

        这里简单介绍一下在 Visual Studio .NET 中调用 MASM 编译独立汇编文件的步骤。

        在 Visual C++ 工程中，添加按 MASM 的要求编写的 .asm 文件。在解决方案资源管理器中，右击这个文件，选择"属性"菜单项，在属性对话框中，点击"自定义生成步骤"，设置如下项目：

        命令行：ML.exe /nologo /c /coff "-Fo$(IntDir)\$(InputName).obj" "$(InputPath)"

        输出：$(IntDir)\$(InputName).obj

        如果要生成调试信息，可以在命令行中加入"/Zi"参数，还可以根据需要生成 .lst 和 .sbr 文件。

        如果要在汇编文件中调用 Windows API，可以从网上下载 MASM 包（包含了 MASM 汇编工具、非常完整的 Windows API 头文件/库文件、实用宏以及大量的 Win 汇编例子等）。相应地，应该在命令行中加入"/I X:\MASM\INCLUDE"参数指定 Windows API 汇编头文件（.inc）的路径。MASM 的主页是：，里面可以下载最新版本的 MASM 包。

完整的C++库函数源代码哪里有下载?

       去官网吧

       /

       这里有C/C++标准库下载

       /tech/stl/download.html

       或直接下压缩包：/tech/stl/stl.tar

       boost

       /projects/boost/files/boost/1..0/