C语言关键字



1.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;
　　}

2.restrict关键字
restrict是c99标准引入的，它只可以用于限定和约束指针，并表明指针是访问一个数据对象的唯一且初始的方式，即它告诉编译器，所有修改该指针所指向内存中内容的操作都必须通过该指针来进行修改，而不能通过其它途径(其它变量或指针)来修改；这样做的好处是能帮助编译器进行更好的优化代码，生成更有效率的汇编代码。如 int *restrict ptr，ptr 指向的内存单元只能被 ptr 访问到，任何同样指向这个内存单元的其他指针都是未定义的，直白点就是无效指针。restrict 的出现是因为 C 语言本身固有的缺陷，C 程序员应当主动地规避这个缺陷，而编译器也会很配合地优化你的代码.
考虑下面的例子：
　　int ar[10];
　　int * restrict restar = (int *)malloc(10 * sizeof(int));
　　int *par = ar;
　　这里说明restar是访问由malloc()分配的内存的唯一且初始的方式。par就不是了。
　　那么：
　　for (n = 0; n < 10; n++)
　　{
　　    par[n] += 5;
　　    restar[n] += 5;
　　    ar[n] *= 2;
　　    par[n] += 3;
　　    restar[n] += 3;
　　}
　　因为restar是访问分配的内存的唯一且初始的方式，那么编译器可以将上述对restar的操作进行优化：
　　restar[n] += 8;
　　而par并不是访问数组ar的唯一方式，因此并不能进行下面的优化：
　　par[n] += 8;
　　因为在par[n] += 3前，ar[n] *= 2进行了改变。使用了关键字restrict，编译器就可以放心地进行优化了。
C库中有两个函数可以从一个位置把字节复制到另一个位置。在C99标准下，它们的原型如下：
　　void * memcpy（void * restrict s1, const void * restrict s2, size_t n);
　　void * memove(void * s1, const void * s2, size_t n);
　　这两个函数均从s2指向的位置复制n字节数据到s1指向的位置，且均返回s1的值。两者之间的差别由关键字restrict造成，即memcpy()可以假定两个内存区域没有重叠。memmove()函数则不做这个假定，因此，复制过程类似于首先将所有字节复制到一个临时缓冲区，然后再复制到最终目的地。如果两个区域存在重叠时使用memcpy()会怎样？其行为是不可预知的，既可以正常工作，也可能失败。在不应该使用memcpy()时，编译器不会禁止使用memcpy()。因此，使用memcpy()时，您必须确保没有重叠区域。这是程序员的任务的一部分。
关键字restrict有两个读者。一个是编译器，它告诉编译器可以自由地做一些有关优化的假定。另一个读者是用户，它告诉用户仅使用满足restrict要求的参数。一般，编译器无法检查您是否遵循了这一限制，如果您蔑视它也就是在让自己冒险。

3.satict关键字

static的用途：

1）声明一个局部静态变量（在函数体内）。

2）声明一个全局静态变量，其作用域局限在声明它的C文件中。

3）声明一个静态函数，该函数被限制在声明它的C文件中使用。

对于函数名和全局变量的static声明类似于C++中的private关键字。

 

4.const关键字

　　我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思？

 const int a;  // const既可在类型前也可在类型后
　　int const a;
　　const int *a;
　　int * const a;
　　int const *a const;
　　
　　前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
　　1). 关键字const 的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。

2). 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
　　3). 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
　

5.typedef关键字　

typedef声明的写法与普通的声明基本相同。typedef关键字用来定义新的类型，其好处是1）可以避免较长的声明；2）便于一些数据类型的修改(可维护性？)；3）可增加代码的可移植性。

 #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 两个指针。

6.sizeof关键字

sizeof是一个关键字，同时也是一个操作符。其作用是返回一个对象或类型（实际）所占的内存单元。

其使用的三种形式：

1）sizeof val;

2）sizeof(val);

3）sizeof(type);

 

char *str = “0123456789”;

char arr[] = “0123456789”;

sizeof(*str) = 1;

sizeof(arr[0]) = 1;

sizeof(str) = 4;

sizeof(arr) = 11;  // include ‘\0’

strlen(arr) = 10;

 

7.#define 

用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
　　#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。
　　#define MIN(A,B) ((A) <= (B) ? (A) : (B))
    least = MIN(*p++, b);

8.位操作（Bit manipulation）

8.1嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。
用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：
　　#define BIT3 (0x1<<3)
　　static int a;
　　void set_bit3(void)
　　{
　　a |= BIT3;
　　}
　　void clear_bit3(void)
　　{
　　a &= ~BIT3;
　　}
8.2嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：
　　int *ptr;
　　ptr = (int *)0x67a9;

*ptr = 0xaa55;
　　
　　一个较晦涩的方法是：
　　*(int * const)(0x67a9) = 0xaa55;

 

9.中断（interrupt）

中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务程序（Interrupt Service Routines，ISR），请评论一下这段代码的。

　　__interrupt double compute_area (double radius)

　　{

　　 double area = PI * radius * radius;

　　 printf(" Area = %f", area);

　　 return area;

　　}

　　void do_irq(void)

　　这个函数有太多的错误了，以至让人不知从何说起了：

　　1). ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。

　　2). ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。

　　3). 在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。

　　4). 与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

 

10.数据声明

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

11.地址

bool compare(const string &strl, const string &strr)

{

if (strl >= strr)

return true;

else

return false;

}

 

int main()

{

bool (* cmp)(const string &, const string &);

string str1("hello"), str2("world");

 

// 函数名与函数名取址数值上是相等（为文本区首地址）

cmp = &compare;  // 函数指针

cout << (*cmp)(str1, str2) << endl;

cmp = compare;

cout << cmp(str1, str2) << endl;

void *p = NULL;

cmp = (bool (*)(const string &, const string &))p; 

 

int arr[5];

void *val;

// 数组名与数组名取址数值上是相等（为该数据首地址）

// 注意arr[i] = *(a + i)的恒等

val = arr; // lea eax,[ebp-90h]; mov dword ptr [ebp-9Ch],eax

cout << val << endl;

val = &arr; // 数组指针int (*arr)[5]

cout << val << endl;

 

return 0;

}