井泉

1.3  虚拟内存访问

每个进程都拥有自己的虚拟地址空间，那么怎样才能访问这个空间呢？这就需要用到Windows API函数。这些函数直接与编写程序相关，因而更受软件工程师的关注。有关这方面的函数较多，这里介绍几个重要的函数。

1.3.1  获取系统信息

在一个程序中不能直接应用某个系统的设备参数，否则将不利于程序的移植。因此，如果确实需要用到这样的设备参数，则需要一个系统信息函数来获得。VC++ 编译器所提供这样的函数为GetSystemInfo()。该函数需要一个指向SYSTEM_INFO结构的指针作为参数。其原型表示为：

l           

void GetSystemInfo(LPSYSTEM_INFO lpSystemInfo);

l           

其中lpSystemInfo返回LPSYSTEM_INFO结构的地址，用于装载适当的系统信息，这个结构体定义为：

l           

typedef struct _SYSTEM_INFO { 

    union {   

        DWORD dwOemId;   

        struct {     

            WORD wProcessorArchitecture;      

            WORD wReserved;   

        };

    }; 

   

    DWORD  dwPageSize; 

    LPVOID  lpMinimumApplicationAddress; 

    LPVOID  lpMaximumApplicationAddress; 

    DWORD_PTR  dwActiveProcessorMask; 

    DWORD  dwNumberOfProcessors; 

    DWORD  dwProcessorType; 

    DWORD  dwAllocationGranularity; 

    WORD   wProcessorLevel; 

    WORD   wProcessorRevision;

} SYSTEM_INFO;

l           

其中参数含义如下所述。

dwOemId：是一个过时选项，用于与Windows NT 3.5以及以前的版本兼容。

wProcessorArchitecture：指明处理的结构，如Intel、Alpha、Intel 64位或Alpha       64位。

dwPageSize：用于显示CPU的页面大小。在x86 CPU上，这个值是4096字节。在Alpha CPU上，这个值是8192字节。在IA-64上，这个值是8192字节。

lpMinimumApplicationAddress：用于给出每个进程可用地址空间的最小内存地址。在Windows 98上，这个值是0x400000，因为每个进程的地址空间中下面的4MB是不能使用的。在Windows 2K/XP上，这个值是0x10000，因为每个进程的地址空间中开头的64KB总是空闲的。

lpMaximumApplicationAddress：用于给出每个进程可用地址空间的最大内存地址。在Windows 98上，这个地址是0x7FFFFFFF，因为共享内存映射文件区域和共享操作系统代码包含在上面的2GB分区中。在Windows XP上，这个地址是0x7FFEFFFF。

dwActiveProcessorMask：位屏蔽，指明哪个CPU是活动的。

dwNumberOfProcessors：计算机中CPU的数目。

dwProcessorType：处理器类型。

dwAllocationGranularity：保留的地址空间区域的分配粒度。

wProcessorLevel：进一步细分处理器的结构。

wProcessorRevision：用于进一步细分处理器的级别。

wReserved：保留供将来使用。

在以上参数中只有lpMinimumApplicationAddress、lpMaximumApplicationAddress、dwPageSize和dwAllocationGranularity与内存有关。

1.3.2  在应用程序中使用虚拟内存

对内存分配可以采用不同的方法，常用的方法有：用C/C++语言的内存分配函数，例如，用malloc() 和 free()、new 和 delete 函数分配和释放堆内存；用Windows传统的全局或者局部内存分配函数，如GlobalAlloc()和GlobalFree()；用Win32的堆分配函数，如HeapAlloc()和HeapFree()；用Win32的虚拟内存分配函数，如VirtualAlloc()和VirtualFree()。注意，用不同的方法分配内存后，要用相对应的函数来释放所占用的内存。这里只介绍Win32的虚拟内存分配函数。

在进程创建之初并被赋予地址空间时，其虚拟地址空间尚未分配，处于空闲状态。这时地址空间内的内存是不能使用的，必须通过VirtualAlloc()函数来分配其中的各个区域，对其进行保留。VirtualAlloc()函数原型为：

l           

LPVOID VirtualAlloc(

    LPVOID lpAddress,

    DWORD dwSize,

    DWORD flAllocationType,

    DWORD flProtect

    );

l           

该函数用来分配一定范围的虚拟页。参数1指定起始地址；参数2指定分配内存的长度；参数3指定分配方式，取值MEM_COMMINT或者MEM_RESERVE；参数4指定控制访问本次分配的内存的标识，取值为PAGE_READONLY、PAGE_READWRITE或者PAGE_NOACCESS。

分配完成后，即在进程的虚拟地址空间中保留了一个区域，可以对此区域中的内存进行保护权限许可范围内的访问。当不再需要访问此地址空间区域时，应释放此区域，由VirtualFree()负责完成。其函数原型为：

l           

BOOL VirtualFree(

    LPVOID lpAddress,

    DWORD dwSize,

    DWORD dwFreeType

    );

l           

其中参数含义如下所述。

lpAddress：指向待释放页面区域的指针。如果参数dwFreeType指定了MEM_RELEASE，则lpAddress必须为页面区域保留由VirtualAlloc()所返回的基地址。

dwSize：指定了要释放的地址空间区域的大小，如果参数dwFreeType指定了MEM_RELEASE标志，则将dwSize设置为0，由系统计算在特定内存地址上的待释放区域的大小。

dwFreeType：为所执行的释放操作的类型，其可能的取值为MEM_RELEASE和MEM_DECOMMIT，其中MEM_RELEASE标志指明要释放指定的保留页面区域，MEM_DECOMMIT标志则对指定的占用页面区域进行占用的解除。

如果VirtualFree()执行完成，将回收全部范围的已分配页面，此后如再对这些已释  放页面区域内存进行访问将引发内存访问异常。释放后的页面区域可供系统继续分配   使用。

1.3.3  获取虚存状态

Windows API函数GlobalMemoryStatus()可用于检索关于当前内存状态的动态信息。在软件的About对话框中，通常用这个函数来获取系统内存的使用情况。其函数原型为：

l           

void GlobalMemoryStatus(LPMEMORYSTATUS lpmstMemStat);

l           

其中lpmstMemStat返回MEMORYSTATUS结构的地址，这个结构体的定义为：

l           

typedef struct MEMORYSTATUS{

    DWORD dwLength;

    DWORD dwMemoryLoad;        

    DWORD dwTotalPhys;

    DWORD dwAvailPhys;

    DWORD dwTotalPageFile;

    DWORD dwAvailPageFile;

    DWORD dwTotalVirtual;

    DWORD dwAvailVirtual; 

} MEMORYSTATUS ,* LPMEMORYSTATUS;

l           

其中参数含义如下所述。

dwLength：MEMORYSTATUS结构大小。

dwMemoryLoad：已使用内存所占的百分比。

dwTotalPhys：物理存储器的总字节数。

dwAvailPhys：空闲物理存储器的字节数。

dwTotalPageFile：页文件包含的最大字节数。

dwAvailPageFile：用户模式分区中空闲内存大小。

dwTotalVirtual：用户模式分区大小。

dwAvailVirtual：表示当前进程中还剩下的自由区域的总和。

在调用GlobalMemoryStatus()之前，必须将dwLength成员初始化为用字节表示的结构的大小，即一个MEMORYSTATUS结构的大小。这个初始化操作使得Microsoft能够在新版本Windows系统中将新成员添加到这个结构中，而不会破坏现有的应用程序。当调用GlobalMemoryStatus()时，它将对该结构的其余成员进行初始化并返回。

如果某个应用程序在内存大于4GB的计算机上运行，或者合计交换文件的大小大于4GB，那么可以使用新的GlobalMemoryStatusEx()函数。其函数的原型为：

l           

BOOL GlobalMemoryStatusEx(MEMORYSTATUSEX  &mst);

l           

其中mst返回MEMORYSTATUSEX结构的填充信息，该结构体与原先的MEMORYSTATUS结构基本相同，差别在于新结构的所有成员的大小都是64位宽，因此它的值可以大于4 GB。

1.3.4  确定虚拟地址空间的状态

对内存的管理除了对当前内存的使用状态信息进行获取外，还经常需要获取有关进程的虚拟地址空间的状态信息。例如，如何得到一个进程已提交的页面范围？这就要用到两个 API函数VirtualQuery()或VirtualQueryEx()来进行查询。这两个函数的功能相似，不同就是VirtualQuery()只是查询本进程内存空间信息，而VirtualQueryEx()可以查询指定进程的内存空间信息。VirtualQuery()函数原型如下：

l           

DWORD VirtualQuery(

    LPVOID lpAddress,     

    PMEMORY_BASIC_INFORMATION lpBuffer,

    DWORD dwLength

    );

l           

VirtualQueryEx()函数原型如下：

l           

DWORD VirtualQueryEx(

    HANDLE hProcess ,

    LPCVOID lpAddress ,

    PMEMORY_BASIC_INFORMATION lpBuffer ,

    DWORD dwLength

    );

l           

其中参数含义如下所述。

hProcess：进程的句柄。

lpAddress：想要了解其信息的虚存地址。

lpBuffer：返回MEMORY_ BASIC_INFORMATION结构的地址。

dwLength：返回的字节数。

PWEMORY_BASIC_INFORMATION的定义如下：

l           

typedef struct _MEMORY_BASIC_INFORMATION{

    PVOID BaseAddress;  

    PVOID AllocationBase;

    DWORD AllocationProtect;

    DWORD RegionSize;

    DWORD State;

    DWORD Protect;

    DWORD Type;

} MEMORY_BASIC_INFORMATION, * PMEMORY_BASIC_INFORMATION;

l           

其中参数含义如下所述。

BaseAddress：被查询内存块的基地址。

AllocationBase：用VirtualAlloc()分配该内存时实际分配的基地址。

AllocationProtect：分配该页面时，页面的一些属性，如PAGE_READWRITE、PAGE_EXECUTE等（其他属性可参考 Platform SDK）。

RegionSize：从BaseAddress开始，具有相同属性的页面的大小。

State：页面的状态，有3种可能值：MEM_COMMIT、MEM_FREE和MEM_ RESERVE，这个参数是最重要的，从中可知指定内存页面的状态。

Protect：页面的属性，它可能的取值与 AllocationProtect 相同。

Type：指明了该内存块的类型，有3种可能值：MEM_IMAGE、MEM_MAPPED和MEM_PRIVATE。

1.3.5  改变内存页面保护属性

在进行进程挂钩时，经常要向内存页中写入部分代码，这就需要改变内存页的保护属性。有幸的是Win32提供了两个API函数VirtualProtect()和VirtualProtectEx()，它们可以对改变内存页保护。例如，在使用这两个函数时，可以先按PAGE_READWRITE属性来提交一个页的地址，并且立即将数据填写到该页中，然后再把该页的属性改变为PAGE_READONLY，这样可以有效地保护数据不被该进程中的任何其他线程重写。在调用这两个函数之前最好先了解有关页面的信息，可以通过VirtualQuery()来实现。

VirtualProtect()与VirtualProtectEx()函数的区别在于VirtualProtect()只适用于本进程，而VirtualProtectEx()可以适用于其他进程。VirtualProtect()函数原型如下：

BOOL VirtualProtect(

    PVOID pvAddress,

    DWORD dwSize,

    DWORD flNewProtect,

    PDWORD pflOldProtect

    );

l           

VirtualProtectEx()函数原型如下：

l           

BOOL VirtualProtectEx(

    HANDLE hProcess,

    PVOID pvAddress,

    DWORD dwSize,

    DWORD flNewProtect,

    PDWORD pflOldProtect

    );

l           

其中参数的含义如下所述。

hProcess：要修改内存的进程句柄。

pvAddress：指向内存的基地址（它必须位于进程的用户方式分区中）。

dwSize：用于指明想要改变保护属性的字节数。

flNewProtect：代表PAGE_*保护属性标志中的任何一个标志，但PAGE_ WRITECOPY和PAGE_EXECUTE_WRITECOPY这两个标志除外。

pflOldProtect：是DWORD大小的地址，VirtualProtect()和VirtualProtectEx()将用原先与pvAddress位置上的字节相关的保护属性填入该地址。尽管许多应用程序并不需要该信息，但是必须为该参数传递一个有效地址，否则该函数的运行将会失败。

1.3.6  进行一个进程的内存读写

前面已经说明了如何获得一个进程的内存属性、如何分配内存和如何改变内存页的保护属性，其最终的目的是要对一个进程中内存内容进行读写。要完成此工作，需要用到两个函数：ReadProcessMemory() 和WriteProcessMemory()，这两个函数非常有用。如果知道了一个进程的句柄和内存地址，就可以用ReadProcessMemory()函数来得到该进程和该地址中的内容，此函数的原型为：

l           

BOOL ReadProcessMemory(

    HANDLE hProcess,

    LPCVOID lpBaseAddress,

    LPVOID lpBuffer,

    DWORD nSize, 

    LPDWORD lpNumberOfBytesRead

    );

l           

其中hProcess为要读入的进程句柄，lpBaseAddress为读内存的起始地址，lpBuffer为读入数据的地址，nSize为要读入的字节数，lpNumberOfBytesRead为实际读入的字   节数。

同样，如果知道了一个进程的句柄和内存地址，可以用WriteProcessMemory()函数向该进程和该地址中写入新的内容，这个函数的原型为：

l           

BOOL WriteProcessMemory(

    HANDLE hProcess,

    LPVOID lpBaseAddress,

    LPVOID lpBuffer,

    DWORD nSize,

    LPDWORD lpNumberOfBytesWritten

    );

l           

其中参数hProcess为要写入的进程句柄，lpBaseAddress为写内存的起始地址，lpBuffer为写入数据的地址，nSize为要写入的字节数，lpNumberOfBytesWritten为实际写入的字节数。

嵌入式设备与桌面PC的一个显著不同是它的应用程序中通常需要直接访问某一段物理内存，这在驱动程序中对物理内存的访问尤为重要，尤其是像ARM体系结构下，I/O端口也被映射成某一个物理内存地址。因此，与桌面版本Windows相比，Windows CE提供了相对简单的物理内存访问方式。无论是驱动程序还是应用程序都可以通过API访问某一段物理内存。

Windows CE的有些函数中需要用到物理内存结构体PHYSICAL_ADDRESS， Windows CE在ceddk.h中定义了PHYSICAL_ADDRESS，它其实是LARGE_INTEGER类型，其定义如下：

// in ceddk.h

typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;

// in winnt.h

typedef union _LARGE_INTEGER{

 struct{

    DWORD LowPart;

    LONG HighPart;

 };

 LONGLONG QuadPart;

} LARGE_INTEGER;

可见，Windows CE中用64个Bit来代表物理地址，对于大多数32位的CPU而言，只需要把它的HighPart设置为0就可以了。

如果要直接访问某一个地址的物理内存，Windows CE提供了VirtualAlloc()和VirtualCopy()函数，VirtualAlloc负责在虚拟内存空间内保留一段虚拟内存，而VirtualCopy负责把一段物理内存和虚拟内存绑定，这样，最终对物理内存的访问还是通过虚拟地址进行。它们的声明如下：

// 申请虚拟内存

LPVOID VirtualAlloc(

 LPVOID lpAddress,     // 希望的虚拟内存起始地址

 DWORD dwSize,             // 以字节为单位的大小

 DWORD flAllocationType,  // 申请类型，分为Reserve和Commit

 DWORD flProtect           // 访问权限

);

// 把物理内存绑定到虚拟地址空间

BOOL VirtualCopy(

 LPVOID lpvDest,           // 虚拟内存的目标地址

 LPVOID lpvSrc,            // 物理内存地址

 DWORD cbSize,             // 要绑定的大小

 DWORD fdwProtect          // 访问权限

);

VirtualAlloc对虚拟内存的申请分为两步，保留MEM_RESERVE和提交MEM_COMMIT。其中MEM_RESERVE只是在进程的虚拟地址空间内保留一段，并不分配实际的物理内存，因此保留的虚拟内存并不能被应用程序直接使用。MEM_COMMIT阶段才真正的为虚拟内存分配物理内存。

下面的代码显示了如何使用VirtualAlloc和VirtualCopy来访问物理内存。因为VirtualCopy负责把一段物理内存和虚拟内存绑定，所以VirtualAlloc的时候只需要对内存保留，没有必要提交。

FpDriverGlobals =

(PDRIVER_GLOBALS) VirtualAlloc(

    0,

    DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,

    MEM_RESERVE,

    PAGE_NOACCESS);

 if (FpDriverGlobals == NULL) {

    ERRORMSG(DRIVER_ERROR_MSG, (TEXT(" VirtualAlloc failed!\r\n")));

    return;

 }

 else {

    if (!VirtualCopy(

    (PVOID)FpDriverGlobals,

    (PVOID)(DRIVER_GLOBALS_PHYSICAL_MEMORY_START),

    DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,

    (PAGE_READWRITE | PAGE_NOCACHE))) {

       ERRORMSG(DRIVER_ERROR_MSG, (TEXT("VirtualCopy failed!\r\n")));

       return;

    }

 }

CEDDK还提供了函数MmMapIoSpace用来把一段物理内存直接映射到虚拟内存。此函数的原形如下：

PVOID MmMapIoSpace(

 PHYSICAL_ADDRESS PhysicalAddress, // 起始物理地址

 ULONG NumberOfBytes,                  // 要映射的字节数

 BOOLEAN CacheEnable                   // 是否缓存

);

其实，MmMapIoSpace函数内部也是调用VirtualAlloc和VirtualCopy函数来实现物理地址到虚拟地址的映射的。MmMapIoSpace函数的原代码是公开的，我们可以从%_WINCEROOT%\PUBLIC\COMMON\OAK\DRIVERS\CEDDK\DDK_MAP\ddk_map.c得到。从MmMapIoSpace的实现我们也可以看出VirtualAlloc和VirtualCopy的用法：

PVOID MmMapIoSpace (

    IN PHYSICAL_ADDRESS PhysicalAddress,

    IN ULONG NumberOfBytes,

    IN BOOLEAN CacheEnable

    )

{

PVOID pVirtualAddress; ULONGLONG SourcePhys;

ULONG SourceSize; BOOL bSuccess;

 

    SourcePhys = PhysicalAddress.QuadPart & ~(PAGE_SIZE - 1);

    SourceSize = NumberOfBytes + (PhysicalAddress.LowPart & (PAGE_SIZE - 1));

 

    pVirtualAddress = VirtualAlloc(0, SourceSize, MEM_RESERVE, PAGE_NOACCESS);

    if (pVirtualAddress != NULL)

    {

        bSuccess = VirtualCopy(

            pVirtualAddress, (PVOID)(SourcePhys >> 8), SourceSize,

            PAGE_PHYSICAL | PAGE_READWRITE | (CacheEnable ? 0 : PAGE_NOCACHE));

 

        if (bSuccess) {

            (ULONG)pVirtualAddress += PhysicalAddress.LowPart & (PAGE_SIZE - 1);

        }

        else {

            VirtualFree(pVirtualAddress, 0, MEM_RELEASE);

            pVirtualAddress = NULL;

        }

    }

    return pVirtualAddress;

}

此外，Windows CE还供了AllocPhysMem函数和FreePhysMem函数，用来申请和释放一段连续的物理内存。函数可以保证申请的物理内存是连续的，如果函数成功，会返回虚拟内存的句柄和物理内存的起始地址。这对于DMA设备尤为有用。在这里就不详细介绍了，读者可以参考Windows CE的联机文档。

---------------------------------------------
定义函数void (* my_function)(void);

在程序中赋值：

my_function = 0x00;

然后调用函数：

my_function();

程序就会跳转到0x00地址开始执行，常用于BootLoader程序中．

类似的还有直接向某个地址写入数据：

int *my_address = 0x05555555;

*my_address = 0x22222222;

直接向0x05555555地址写入数据0x22222222.

对于普通类型的对象来说，它们之间的复制是很简单的，例如：

int a=100; int b=a;

　　而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。

#include <iostream> using namespace std; class CA { 　public: 　　CA(int b) 　　{ 　　　a=b; 　　} 　　void Show () 　　{ 　　　cout<<a<<endl; 　　} 　private: 　　int a; }; int main() { 　CA A(100); 　CA B=A; 　B.Show (); 　return 0; }

　　运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面我们举例说明拷贝构造函数的工作过程。

#include <iostream> using namespace std; class CA { 　public: 　　CA(int b) 　　{ 　　　a=b; 　　} 　　CA(const CA& C) 　　{ 　　　a=C.a; 　　} 　　void Show() 　　{ 　　　cout<<a<<endl; 　　} 　private: 　　int a; }; int main() { 　CA A(100); 　CA B=A; 　B.Show (); 　return 0; }

　　CA(const CA& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

　　当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：

　　一个对象以值传递的方式传入函数体

　　一个对象以值传递的方式从函数返回

　　一个对象需要通过另外一个对象进行初始化。

　　如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。

　　自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

　　浅拷贝和深拷贝

　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

#include <iostream> using namespace std; class CA { 　public: 　　CA(int b,char* cstr) 　　{ 　　　a=b; 　　　str=new char[b]; 　　　strcpy(str,cstr); 　　} 　　CA(const CA& C) 　　{ 　　　a=C.a; 　　　str=new char[a]; //深拷贝 　　　if(str!=0) 　　　　strcpy(str,C.str); 　　} 　　void Show() 　　{ 　　　cout<<str<<endl; 　　} 　　~CA() 　　{ 　　　delete str; 　　} 　private: 　　int a; 　　char *str; }; int main() { 　CA A(10,"Hello!"); 　CA B=A; 　B.Show(); 　return 0; }

　　好吧，就说这些，希望本文能对您有所帮助。

#include "stdarg.h"
int my_printf (const char *format, ...)
{
 va_list arg;
 int done;
 
 va_start (arg, format);
 done = vprintf (format, arg);
 va_end (arg);
 return done;
}

vprintf是printf的底层实现细节
加上宏定义就可以方便的实现开/关调试信息了。

<本文中排序都是采用的从小到大排序>

一、对int类型数组排序

int num[100];

Sample:

int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}

qsort(num,100,sizeof(num[0]),cmp);

二、对char类型数组排序（同int类型）

char word[100];

Sample:

int cmp( const void *a , const void *b )
{
return *(char *)a - *(int *)b;
}

qsort(word,100,sizeof(word[0]),cmp);

三、对double类型数组排序（特别要注意）

double in[100];

int cmp( const void *a , const void *b )
{
return *(double *)a > *(double *)b ? 1 : -1;
}

qsort(in,100,sizeof(in[0]),cmp)；

四、对结构体一级排序

struct In
{
double data;
int other;
}s[100]

//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写

int cmp( const void *a ,const void *B)
{
return (*(In *)a)->data > (*(In *)B)->data ? 1 : -1;
}

qsort(s,100,sizeof(s[0]),cmp);

五、对结构体二级排序

struct In
{
int x;
int y;
}s[100];

//按照x从小到大排序，当x相等时按照y从大到小排序

int cmp( const void *a , const void *b )
{
struct In *c = (In *)a;
struct In *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
else return d->y - c->y;
}

qsort(s,100,sizeof(s[0]),cmp);

六、对字符串进行排序

struct In
{
int data;
char str[100];
}s[100];

//按照结构体中字符串str的字典顺序排序

int cmp ( const void *a , const void *b )
{
return strcmp( (*(In *)a)->str , (*(In *)B)->str );
}

qsort(s,100,sizeof(s[0]),cmp);

七、计算几何中求凸包的cmp

int cmp(const void *a,const void *B) //重点cmp函数，把除了1点外的所有点，旋转角度排序
{
struct point *c=(point *)a;
struct point *d=(point *)b;
if( calc(*c,*d,p[1]) < 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直线上，则把远的放在前面
return 1;
else return -1;
}

PS:

其中的qsort函数包含在<stdlib.h>的头文件里，strcmp包含在<string.h>的头文件里

1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。

2 . 写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个。
#define MIN(A,B) （（A） <= (B) ? (A) : (B)) 这个测试是为下面的目的而设的：
1) 标识#define在宏中应用的基本知识。这是很重要的。因为在 嵌入(inline)操作符 变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。
3) 懂得在宏中小心地把参数用括号括起来
4) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？
least = MIN(*p++, b);

3. 预处理器标识#error的目的是什么？
如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。

死循环（Infinite loops）
4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？ 这个问题用几个解决方案。
我首选的方案是：
while(1)
{

}
一些程序员更喜欢如下方案：
for(;;)
{

}
这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是："我被教着这样做，但从没有想到过为什么。"这会给我留下一个坏印象。
第三个方案是用 goto
Loop:
...
goto Loop;
应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。

数据声明（Data declarations）
5. 用变量a给出下面的定义
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to
integers）
f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function
that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that
takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to
functions that take an integer argument and return an
integer
人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢？

Static
6. 关键字static的作用是什么？
这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。

Const
7．关键字const有什么含意？
我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan
Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems
Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
/******/
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 ，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

Volatile
8. 关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1) 并行设备的硬件寄存器（如：状态寄存器）
2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3) 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。 假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1)一个参数既可以是const还可以是volatile吗？解释为什么。
2); 一个指针可以是volatile 吗？解释为什么。
3); 下面的函数有什么错误：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2); 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

位操作（Bit manipulation）
9. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。 对这个问题有三种基本的反应
1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
2) 用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。
3) 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：
#define BIT3 (0x1 << 3)
static int a;
void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}

一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可以接受的。我希望看到几个要点：说明常数、|=和&=~操作。

访问固定的内存位置（Accessing fixed memory locations）
10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。
在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;
A more obscure approach is: ( 一个较晦涩的方法是)：
*(int * const)(0x67a9) = 0xaa55;
即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。

中断（Interrupts）
11.
中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。
__interrupt double compute_area (double radius)
{
double area = PI * radius * radius;
printf("\nArea = %f", area);
return area;
}
这个函数有太多的错误了，以至让人不知从何说起了：
1)ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。
2) ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
3) 在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
4) 与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

代码例子（Code examples）
12 . 下面的代码输出是什么，为什么？
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

13. 评价下面的代码片断：
unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1's complement of zero */
对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：
unsigned int compzero = ~0;
这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。
到了这个阶段，应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好，那么这个测试就在这里结束了。但如果显然应试者做得不错，那么我就扔出下面的追加问题，这些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提出这些问题，我希望更多看到应试者应付问题的方法，而不是答案。不管如何，你就当是这个娱乐吧...

动态内存分配（Dynamic memory allocation）
14.
尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？这里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：下面的代码片段的输出是什么，为什么？
char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");
这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码的输出是"Got a valid pointer"。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基本原理更重要些。

Typedef
15 Typedef
在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：
#define dPS struct s *
typedef struct s * tPS;
以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：
dPS p1,p2;
tPS p3,p4;
第一个扩展为
struct s * p1, p2;
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

晦涩的语法
16 . C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？
int a = 5, b = 7, c;
c = a+++b;
这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：c = a++ + b;
因此, 这段代码持行后a = 6, b = 7, c = 12。
如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。

基本概念

库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。例如：libhello.so libhello.a

为了在同一系统中使用不同版本的库，可以在库文件名后加上版本号为后缀,例如： libhello.so.1.0,由于程序连接默认以.so为文件后缀名。所以为了使用这些库，通常使用建立符号连接的方式。
ln -s libhello.so.1.0 libhello.so.1
ln -s libhello.so.1 libhello.so

使用库

当要使用静态的程序库时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。然而，对动态库而言，就不是这样。动态库会在执行程序内留下一个标记‘指明当程序执行时，首先必须载入这个库。由于动态库节省空间，linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。
现在假设有一个叫hello的程序开发包，它提供一个静态库libhello.a 一个动态库libhello.so,一个头文件hello.h,头文件中提供sayhello()这个函数
/* hello.h */
void sayhello();
另外还有一些说明文档。这一个典型的程序开发包结构
1.与动态库连接
linux默认的就是与动态库连接，下面这段程序testlib.c使用hello库中的sayhello()函数

/*testlib.c*/
#include <hello.h>
#include <stdio.h>

int main()
{
sayhello();
return 0;
}

使用如下命令进行编译
$gcc -c testlib.c -o testlib.o
用如下命令连接：
$gcc testlib.o -lhello -o testlib
在连接时要注意，假设libhello.o 和libhello.a都在缺省的库搜索路径下/usr/lib下，如果在其它位置要加上-L参数
与与静态库连接麻烦一些，主要是参数问题。还是上面的例子：
$gcc testlib.o -o testlib -WI,-Bstatic -lhello
注：这个特别的"-WI，-Bstatic"参数，实际上是传给了连接器ld.
指示它与静态库连接，如果系统中只有静态库当然就不需要这个参数了。
如果要和多个库相连接，而每个库的连接方式不一样，比如上面的程序既要和libhello进行静态连接，又要和libbye进行动态连接，其命令应为：
$gcc testlib.o -o testlib -WI,-Bstatic -lhello -WI,-Bdynamic -lbye
3.动态库的路径问题
为了让执行程序顺利找到动态库，有三种方法：
(1)把库拷贝到/usr/lib和/lib目录下。
(2)在LD_LIBRARY_PATH环境变量中加上库所在路径。例如动态库libhello.so在/home/ting/lib目录下，以bash为例，使用命令：
$export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/ting/lib
(3) 修改/etc/ld.so.conf文件，把库所在的路径加到文件末尾，并执行ldconfig刷新。这样，加入的目录下的所有库文件都可见、
4.查看库中的符号
有时候可能需要查看一个库中到底有哪些函数，nm命令可以打印出库中的涉及到的所有符号。库既可以是静态的也可以是动态的。nm列出的符号有很多，常见的有三种，一种是在库中被调用，但并没有在库中定义(表明需要其他库支持)，用U表示；一种是库中定义的函数，用T表示，这是最常见的；另外一种是所谓的“弱态”符号，它们虽然在库中被定义，但是可能被其他库中的同名符号覆盖，用W表示。例如，假设开发者希望知道上央提到的hello库中是否定义了printf():
$nm libhello.so |grep printf
U printf
U表示符号printf被引用，但是并没有在函数内定义，由此可以推断，要正常使用hello库，必须有其它库支持，再使用ldd命令查看hello依赖于哪些库：
$ldd hello
libc.so.6=>/lib/libc.so.6(0x400la000)
/lib/ld-linux.so.2=>/lib/ld-linux.so.2 (0x40000000)
从上面的结果可以继续查看printf最终在哪里被定义，有兴趣可以go on


生成库

第一步要把源代码编绎成目标代码。以下面的代码为例，生成上面用到的hello库：
/* hello.c */
#include <stdio.h>
void sayhello()
{
printf("hello,world\n");
}
用gcc编绎该文件，在编绎时可以使用任何全法的编绎参数，例如-g加入调试代码等：
gcc -c hello.c -o hello.o

1.连接成静态库
连接成静态库使用ar命令，其实ar是archive的意思
$ar cqs libhello.a hello.o
2.连接成动态库
生成动态库用gcc来完成，由于可能存在多个版本，因此通常指定版本号：
$gcc -shared -Wl,-soname,libhello.so.1 -o libhello.so.1.0 hello.o
另外再建立两个符号连接：
$ln -s libhello.so.1.0 libhello.so.1
$ln -s libhello.so.1 libhello.so
这样一个libhello的动态连接库就生成了。最重要的是传gcc -shared 参数使其生成是动态库而不是普通执行程序。
-Wl 表示后面的参数也就是-soname,libhello.so.1直接传给连接器ld进行处理。实际上，每一个库都有一个soname，当连接器发现它正在查找的程序库中有这样一个名称，连接器便会将soname嵌入连结中的二进制文件内，而不是它正在运行的实际文件名，在程序执行期间，程序会查找拥有soname名字的文件，而不是库的文件名，换句话说，soname是库的区分标志。
这样做的目的主要是允许系统中多个版本的库文件共存，习惯上在命名库文件的时候通常与soname相同
libxxxx.so.major.minor
其中，xxxx是库的名字，major是主版本号，minor 是次版本号

概述
　　C语言的内存模型基本上对应了现在von Neumann（冯·诺伊曼）计算机的实际存储模型，很好的达到了对机器的映射，这是C/C++适合做底层开发的主要原因，另外，C语言适合做底层开发还有另外一个原因，那就是C语言对底层操作做了很多的的支持，提供了很多比较底层的功能。
　　下面结合问题分别进行阐述。
　　问题：移位操作
　　在运用移位操作符时，有两个问题必须要清楚：
　　(1)、在右移操作中，腾空位是填 0 还是符号位；
　　(2)、什么数可以作移位的位数。
答案与分析：
　　">>"和"<<"是指将变量中的每一位向右或向左移动, 其通常形式为 :
　　右移: 变量名>>移位的位数
　　左移: 变量名<<移位的位数
　　经过移位后, 一端的位被"挤掉",而另一端空出的位以0 填补,在C语言中的移位不是循环移动的。
　　(1) 第一个问题的答案很简单，但要根据不同的情况而定。如果被移位的是无符号数，则填 0 。如果是有符号数，那么可能填 0 或符号位。如果你想解决右移操作中腾空位的填充问题，就把变量声明为无符号型，这样腾空位会被置 0。

　　(2) 第二个问题的答案也很简单：如果移动 n 位，那么移位的位数要不小于 0 ，并且一定要小于 n 。这样就不会在一次操作中把所有数据都移走。

　　比如，如果整型数据占 32 位，n 是一整型数据，则 n << 31 和 n << 0 都合法，而 n << 32 和 n << -1 都不合法。

　　注意即使腾空位填符号位，有符号整数的右移也不相当与除以。为了证明这一点，我们可以想一下 -1 >> 1 不可能为 0 。

　　问题：位段结构

struct RPR_ATD_TLV_HEADER
{
ULONG res1:6;
ULONG type:10;
ULONG res1:6;
ULONG length:10;
};

　　位段结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构比按位运算符更加方便。

　　位结构定义的一般形式为:

struct 位结构名 {
　数据类型 变量名: 整型常数 ;
　数据类型 变量名: 整型常数 ;
} 位结构变量;  

　　其中: 整型常数必须是非负的整数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。

　　变量名是选择项, 可以不命名, 这样规定是为了排列需要。

　　例如: 下面定义了一个位结构。

struct{
　unsigned incon: 8; /*incon占用低字节的0~7共8位 */
　unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位 */
　unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位 */
　unsigned blink: 1; /*blink占用高字节的第7位 */
}ch;  

　　位结构成员的访问与结构成员的访问相同。

　　例如: 访问上例位结构中的bgcolor成员可写成:

ch.bgcolor  

　　位结构成员可以与其它结构成员一起使用。按位访问与设置，方便&节省

　　例如:

struct info{
　 char name[8];
　 int age;
　 struct addr address;
　 float pay;
　 unsigned state: 1;
　 unsigned pay: 1;
}workers;'  

　　上例的结构定义了关于一个工从的信息。其中有两个位结构成员, 每个位结构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。

　　注意不要超过值限制

　　问题：字节对齐

　　我在使用VC编程的过程中，有一次调用DLL中定义的结构时，发觉结构都乱掉了，完全不能读取正确的值，后来发现这是因为DLL和调用程序使用的字节对齐选项不同，那么我想问一下，字节对齐究竟是怎么一回事？

　　答案与分析：

　　关于字节对齐：

　　1、 当不同的结构使用不同的字节对齐定义时，可能导致它们之间交互变得很困难。

　　2、 在跨CPU进行通信时，可以使用字节对齐来保证唯一性，诸如通讯协议、写驱动程序时候寄存器的结构等。

　　三种对齐方式：

　　1、 自然对齐方式（Natural Alignment）：与该数据类型的大小相等。

　　2、 指定对齐方式 ：

#pragma pack(8) // 指定Align为 8；
#pragma pack() // 恢复到原先值

　　3、 实际对齐方式：

Actual Align = min ( Order Align, Natual Align )

　　对于复杂数据类型（比如结构等）：实际对齐方式是其成员最大的实际对齐方式：

Actual Align = max( Actual align1,2,3，…)

　　编译器的填充规律：

　　1、 成员为成员Actual Align的整数倍，在前面加Padding。

　　成员Actual Align = min( 结构Actual Align，设定对齐方式)

　　2、 结构为结构Actual Align的整数倍，在后面加Padding.

　　例子分析：

#pragma pack(8) // 指定Align为 8
struct STest1
{
char ch1;
long lo1;
char ch2;
} test1;
#pragma pack()

　　现在

Align of STest1 = 4 , sizeof STest1 = 12 ( 4 * 3 )

　　test1在内存中的排列如下（ FF 为 padding ）：

00 -- -- -- 04 -- -- -- 08 -- -- -- 12 -- -- --
01 FF FF FF 01 01 01 01 01 FF FF FF
ch1 -- lo1 -- ch2
#pragma pack(2) // 指定Align为 2
struct STest2
{
char ch3;
STest1 test;
} test2;
#pragma pack()

　　现在 Align of STest1 = 2, Align of STest2 = 2 , sizeof STest2 = 14 ( 7 * 2 )

　　test2在内存中的排列如下：

00 -- -- -- 04 -- -- -- 08 -- -- -- 12 -- -- --
02 FF 01 FF FF FF 01 01 01 01 01 FF FF FF
ch3 ch1 -- lo1 -- ch2

　　注意事项：

　　1、 这样一来，编译器无法为特定平台做优化，如果效率非常重要，就尽量不要使用#pragma pack，如果必须使用，也最好仅在需要的地方进行设置。

　　2、 需要加pack的地方一定要在定义结构的头文件中加，不要依赖命令行选项，因为如果很多人使用该头文件，并不是每个人都知道应该pack。这特别表现在为别人开发库文件时，如果一个库函数使用了struct作为其参数，当调用者与库文件开发者使用不同的pack时，就会造成错误，而且该类错误很不好查。

　　3、 在VC及BC提供的头文件中，除了能正好对齐在四字节上的结构外，都加了pack，否则我们编的Windows程序哪一个也不会正常运行。

　　4、 在 #pragma pack(n) 后一定不要include其他头文件，若包含的头文件中改变了align值，将产生非预期结果。

　　5、 不要多人同时定义一个数据结构。这样可以保证一致的pack值。

　　问题：按位运算符

　　C语言和其它高级语言不同的是它完全支持按位运算符。这与汇编语言的位操作有些相似。 C中按位运算符列出如下:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━
操作符 作用
────────────────────────────
& 位逻辑与
| 位逻辑或
^ 位逻辑异或
- 位逻辑反
>> 右移
<< 左移
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

　　注意：

　　1、 按位运算是对字节或字中的实际位进行检测、设置或移位, 它只适用于字符型和整数型变量以及它们的变体, 对其它数据类型不适用。

　　2、 关系运算和逻辑运算表达式的结果只能是1或0。 而按位运算的结果可以取0或1以外的值。要注意区别按位运算符和逻辑运算符的不同, 例如, 若x=7, 则x&&8 的值为真(两个非零值相与仍为非零), 而x&8的值为0。

　　3、 | 与 ||，&与&&，~与! 的关系

　　&、| 和 ~ 操作符把它们的操作数当作一个为序列，按位单独进行操作。比如：10 & 12 = 8，这是因为"&"操作符把 10 和 12 当作二进制描述 1010 和 1100 ，所以只有当两个操作数的相同位同时为 1 时，产生的结果中相应位才为 1 。同理，10 | 12 = 14 ( 1110 )，通过补码运算，~10 = -11 ( 11...110101 )。<以多少为一个位序列> &&、|| 和！操作符把它们的操作数当作"真"或"假"，并且用 0 代表"假"，任何非 0 值被认为是"真"。它们返回 1 代表"真"，0 代表"假"，对于"&&"和"||"操作符，如果左侧的操作数的值就可以决定表达式的值，它们根本就不去计算右侧的操作数。所以，!10 是 0 ，因为 10 非 0 ；10 && 12 是 1 ，因为 10 和 12 均非 0 ；10 || 12也是 1 ，因为 10 非 0 。并且，在最后一个表达式中，12 根本就没被计算，在表达式 10 || f( ) 中也是如此。