inline  关键字用来定义一个类的内联函数，引入它的主要原因是用它替代C中表达式形式的宏定义。 
   
  表达式形式的宏定义一例： 
   
    　#define  ExpressionName(Var1,Var2)  (Var1+Var2)*(Var1-Var2) 
   
  为什么要取代这种形式呢，且听我道来： 
   
    1．   
  首先谈一下在C中使用这种形式宏定义的原因，C语言是一个效率很高的语言，这种宏定义在形式及使用上像一个函数，但它使用预处理器实现，没有了参数压栈，代码生成等一系列的操作,因此，效率很高，这是它在C中被使用的一个主要原因。 
   
    2．   
  这种宏定义在形式上类似于一个函数，但在使用它时，仅仅只是做预处理器符号表中的简单替换，因此它不能进行参数有效性的检测，也就不能享受C++编译器严格类型检查的好处，另外它的返回值也不能被强制转换为可转换的合适的类型，这样，它的使用就存在着一系列的隐患和局限性。 
   
    3．   
  在C++中引入了类及类的访问控制，这样，如果一个操作或者说一个表达式涉及到类的保护成员或私有成员，你就不可能使用这种宏定义来实现(因为无法将this指针放在合适的位置)。 
   
    4．  inline  推出的目的，也正是为了取代这种表达式形式的宏定义，它消除了它的缺点，同时又很好地继承了它的优点。 
   
  为什么inline能很好地取代表达式形式的预定义呢？ 
   
  对应于上面的1-3点，阐述如下： 
   
    1．  inline  定义的类的内联函数，函数的代码被放入符号表中，在使用时直接进行替换，（像宏一样展开），没有了调用的开销，效率也很高。   
   
    2．   
  很明显，类的内联函数也是一个真正的函数，编译器在调用一个内联函数时，会首先检查它的参数的类型，保证调用正确。然后进行一系列的相关检查，就像对待任何一个真正的函数一样。这样就消除了它的隐患和局限性。   
   
   
    3．  inline  可以作为某个类的成员函数，当然就可以在其中使用所在类的保护成员及私有成员。   
  在何时使用inline函数： 
   
    首先，你可以使用inline函数完全取代表达式形式的宏定义。 
   
    另外要注意，内联函数一般只会用在函数内容非常简单的时候，这是因为，内联函数的代码会在任何调用它的地方展开，如果函数太复杂，代码膨胀带来的恶果很可能会大于效率的提高带来的益处。
从两道经典试题谈C/C++中联合体（union）的使用
试题一：编写一段程序判断系统中的CPU是Little endian还是Big endian模式？
分析：
作为一个计算机相关专业的人，我们应该在计算机组成中都学习过什么叫Little endian和Big endian。Little endian和Big endian是CPU存放数据的两种不同顺序。对于整型、长整型等数据类型，Big endian认为第一个字节是最高位字节（按照从低地址到高地址的顺序存放数据的高位字节到低位字节）；而Little endian则相反，它认为第一个字节是最低位字节（按照从低地址到高地址的顺序存放数据的低位字节到高位字节）。
例如，假设从内存地址0x0000开始有以下数据：
0x0000
0x0001
0x0002
0x0003
0x12
0x34
0xab
0xcd
如果我们去读取一个地址为0x0000的四个字节变量，若字节序为big-endian，则读出结果为0x1234abcd；若字节序位little-endian，则读出结果为0xcdab3412。如果我们将0x1234abcd写入到以0x0000开始的内存中，则Little endian和Big endian模式的存放结果如下：
地址
0x0000
0x0001
0x0002
0x0003
big-endian
0x12
0x34
0xab
0xcd
little-endian
0xcd
0xab
0x34
0x12
一般来说，x86系列CPU都是little-endian的字节序，PowerPC通常是Big endian，还有的CPU能通过跳线来设置CPU工作于Little endian还是Big endian模式。
解答：
显然，解答这个问题的方法只能是将一个字节（CHAR/BYTE类型）的数据和一个整型数据存放于同样的内存开始地址，通过读取整型数据，分析CHAR/BYTE数据在整型数据的高位还是低位来判断CPU工作于Little endian还是Big endian模式。得出如下的答案：
typedef unsigned char BYTE;
int main(int argc, char* argv[])
{
      unsigned int num,*p;
    p = #
      num = 0;
 
    *(BYTE *)p = 0xff;
     
      if(num == 0xff)
      {
              printf("The endian of cpu is little\n");
      }
      else    //num == 0xff000000
      {
              printf("The endian of cpu is big\n");
      }
      return 0;
}
除了上述方法(通过指针类型强制转换并对整型数据首字节赋值，判断该赋值赋给了高位还是低位)外，还有没有更好的办法呢？我们知道，union的成员本身就被存放在相同的内存空间（共享内存，正是union发挥作用、做贡献的去处），因此，我们可以将一个CHAR/BYTE数据和一个整型数据同时作为一个union的成员，得出如下答案：
int checkCPU()
{
　{
  union w
  {
  　int a;
  　char b;
  } c;
  c.a = 1;
  return (c.b == 1);
　}
}
实现同样的功能，我们来看看Linux操作系统中相关的源代码是怎么做的：
static union { char c[4]; unsigned long l; } endian_test = { { 'l', '?', '?', 'b' } };
#define ENDIANNESS ((char)endian_test.l)
Linux的内核作者们仅仅用一个union变量和一个简单的宏定义就实现了一大段代码同样的功能！由以上一段代码我们可以深刻领会到Linux源代码的精妙之处！
试题二：假设网络节点A和网络节点B中的通信协议涉及四类报文，报文格式为“报文类型字段+报文内容的结构体”，四个报文内容的结构体类型分别为STRUCTTYPE1~ STRUCTTYPE4，请编写程序以最简单的方式组织一个统一的报文数据结构。
分析：
报文的格式为“报文类型+报文内容的结构体”，在真实的通信中，每次只能发四类报文中的一种，我们可以将四类报文的结构体组织为一个union（共享一段内存，但每次有效的只是一种），然后和报文类型字段统一组织成一个报文数据结构。
解答：
根据上述分析，我们很自然地得出如下答案：
typedef unsigned char BYTE;
 
//报文内容联合体
typedef union tagPacketContent
{
      STRUCTTYPE1 pkt1;
      STRUCTTYPE2 pkt2;
      STRUCTTYPE3 pkt1;
      STRUCTTYPE4 pkt2;
}PacketContent;
 
//统一的报文数据结构
typedef struct tagPacket
{
      BYTE pktType;
    PacketContent pktContent;
}Packet;
总结
在C/C++程序的编写中，当多个基本数据类型或复合数据结构要占用同一片内存时，我们要使用联合体（试题一是这样的例证）；当多种类型，多个对象，多个事物只取其一时（我们姑且通俗地称其为“n选1”），我们也可以使用联合体来发挥其长处（试题二是这样的例证）。
位域

有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域， 并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：
struct 位域结构名
{ 位域列表 };
其中位域列表的形式为： 类型说明符 位域名：位域长度
例如：
struct bs
{
int a:8;
int b:2;
int c:6;
};
位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：
struct bs
{
int a:8;
int b:2;
int c:6;
}data;
说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：

1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一
位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：
struct bs
{
unsigned a:4
unsigned :0 /*空域*/
unsigned b:4 /*从下一单元开始存放*/
unsigned c:4
}
在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。

2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。

3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：
struct k
{
int a:1
int :2 /*该2位不能使用*/
int b:3
int c:2
};
从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。

二、位域的使用位域的使用和结构成员的使用相同，其一般形式为： 位域变量名·位域名 位域允许用各种格式输出。
main(){
struct bs
{
unsigned a:1;
unsigned b:3;
unsigned c:4;
} bit,*pbit;
bit.a=1;
bit.b=7;
bit.c=15;
printf("%d,%d,%d\n",bit.a,bit.b,bit.c);
pbit=&bit;
pbit->a=0;
pbit->b&=3;
pbit->c|=1;
printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);
}
上例程序中定义了位域结构bs，三个位域为a,b,c。说明了bs类型的变量bit和指向bs类型的指针变量pbit。这表示位域也是可以使用指针的。
程序的9、10、11三行分别给三个位域赋值。( 应注意赋值不能超过该位域的允许范围)程序第12行以整型量格式输出三个域的内容。第13行把位域变量bit的地址送给指针变量pbit。第14行用指针方式给位域a重新赋值，赋为0。第15行使用了复合的位运算符"&="， 该行相当于： pbit->b=pbit->b&3位域b中原有值为7，与3作按位与运算的结果为3(111&011=011,十进制值为3)。同样，程序第16行中使用了复合位运算"|="， 相当于： pbit->c=pbit->c|1其结果为15。程序第17行用指针方式输出了这三个域的值。
union是什么类型
C语言关键字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;
}

================================================================================
volatile的本意是“易变的”
由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：

static int i="0";

int main(void)
{
  ...
  while (1)
  {
    if (i) dosomething();
  }
}

/* Interrupt service routine. */
void ISR_2(void)
{
  i="1";
}

程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被调用。如果将
将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。
================================================================================

一般说来，volatile用在如下的几个地方：
1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
2、多任务环境下各任务间共享的标志应该加volatile；
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能有不同意义；

另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过有关中断来实现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。

volatile 的含义
volatile总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步可以使代码消除。但有时这些优化不是程序所需要的，这时可以用volatile关键字禁止做这些优化，volatile的字面含义是易变的，它有下面的作用：

1、不会在两个***作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环境下，变量可能被其他的程序改变，编译器自己无法知道，volatile就是告诉编译器这种情况。

2、不做常量合并、常量传播等优化，所以像下面的代码：
volatile int i = 1;
if (i > 0) ...

if的条件不会当作无条件真。

3、对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到，编译器常常可以省略那个赋值***作，然而对Memory Mapped IO的处理是不能这样优化的。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。