C与指针 随笔

第三章 数据

const* 与 *const

int const* p;

*p是一个整型常量。所以p是这样一个指针，它所指向的变量的值不可修改，但是p的值可修改，也就是说p可以指向其他变量。

int *const p;

p是一个常量指针，也就是说p不可以再改变指向，它只能指向它一开始指向的变量。但是可以通过p修改它所指向的变量的值。数组正是这样的一种指针。

第四章 语句

空循环体

while((ch=getchar())!=EOF&&ch!='\0')
    ;

这样做的好处是清楚地显示了循环体是空的，不至于使人误会程序接下来地一条语句才是循环体。

判断闰年：先从最为特殊的情况开始

if(year%400==0){
    leap_year=1;
}
else if(year%100==0){
    leap_year=0;
}
else if(year%4==0){
    leap_year=1;
}
else{
    leap_year=0;
}

getchar()的返回值

首先认为语句

a=x=y+3;

中a和x的值相等这件事是错误的。因为假如x是char型，a、y是int型，那么将 y+3 赋给x，x便会截取赋值，此时a的值将不会等于 y+3。而 getchar() 函数的返回值也是int,则语句

char ch;
......
while((ch=getchar())!=EOF){
    statements;
}

是有一定几率发生错误的。比如说当你输入的为 \377 字符时，被截取后再提上来和 EOF 相等。

逗号运算符

ch=getchar();
while(ch!='\n'){
    ......
    ch=getchar();
}

和

while(ch=getchar(),ch!='\n'){
    ......
}

等价。因为表达式的真假只和最后一个逗号后面的表达式有关。

第五章 操作符与表达式

优先级问题

语句

x=f()+g()+z();

中，虽然按照优先级后一个加法是在前一个加法之后进行。但是对于函数调用的顺序却没有一个确定的规则可循。假如函数都对某一个 全局变量 进行调用修改，那么x的最终结果就将无法确定。从而此语句不具有可移植性。最好改为

temp=f();
temp+=g();
temp+=z();

第六章 指针

指针二则运算

如果一个指针减去一个整数后，运算结果产生的指针所指向的位置在数组第一个元素之前，那么它是 非法的 。加法运算稍有不同，结果指针指向数组最后一个元素后面的那个内存位置仍是 合法 （但不能对这个指针执行间接访问操作），不过再往后就不合法了。

第七章 函数

函数的缺省认定

当函数调用一个无法见到原型的函数时，编译器便会认为该函数返回一个整型值。

函数的参数

C语言的规则很简单：

所有参数都是传值调用。

数组参数的传址调用看起来似乎和传值调用相悖。但是，此处其实并无矛盾之处——数组名的值实际上是一个指针，传递给函数的就是这个指针的一份拷贝。

第八章 数组

下标引用

array[2] 和 2[array] 和 *(array+2) 是等价的。因为前两者都会以第三种方式解释。
对二维数组，假如申请了一个名为 array[M][N] 的数组，
则 array[2][3] 会被解释成 * ( *（array+2）+3) ,这也就是为什么在函数传递二维数组时必须标明 纵轴 最大值（如：Func(a[][N])）。

各类数组声明

以下声明为旧式风格，忽略了函数的参数。

char a[MAX];//元素类型为字符
int a[MAX];//元素类型为整数
float a[MAX];//元素类型为浮点数

char *a[MAX];//元素类型为指向字符型变量的指针
int *a[MAX];//元素类型为指向整型变量的指针
float *a[MAX];//元素类型为指向浮点型变量的指针

char (*a)[MAX]()//元素类型为函数指针，这个函数指针指向一个返回值为字符型的函数
int (*a)[MAX]();//元素类型为函数指针，这个函数指针指向一个返回值为整型的函数
float (*a)[MAX]();//元素类型为函数指针，这个函数指针指向一个返回值为浮点型的函数

char *(*a)[MAX]()//元素类型为函数指针，这个函数指针指向一个返回值为字符型指针的函数
int *(*a)[MAX]();//元素类型为函数指针，这个函数指针指向一个返回值为整型指针的函数
float *(*a)[MAX]();//元素类型为函数指针，这个函数指针指向一个返回值为浮点型指针的函数

第九章 字符串、字符和字节

strlen()函数的返回值

以下两个语句不是等价的：

if(strlen(x)>=strlen(y)){...}
if(strlen(x)-strlen(y)>=0){...}

由于strlrn()函数的返回值是size_t（定义在stdlib.h中，和unsigned类型等价）型，所以strlen(x)-strlen(y)的结果将永远为无符号整型，亦即上述第二个语句将永远为真。其实该函数返回值为无符号整形也是有优点的，它能表示字符串更大的长度。

strncpy()的第三个参数

char *strncpy(char *dst,char const *src,size_t len);

和strcpy()函数一样，strncpy()把源字符串的字符复制到目标数组。然而，他总是正好向dst写入 len个字符。如果strlen(dst)的值小于len， dst数组就用额外的NUL字节填充到len长度。如果strlen(dst)的值大于或等于len，那么只有len个字符被复制到dst。 注意：它的结果将不会以NUL字节结尾。

字符分类函数

举个例子，用

if(isalpha(ch)){...}

代替

if(ch>='A'&&ch<='Z'||ch>='a'&&ch<='z'){...}

明显更简洁。其中isXXX()类函数包含在ctype.h头文件中。

第十三章 高级指针话题

函数指针

int f(int);
int (*pf)(int)=&f;
int ans;
//ans=f(25);
//ans=(*pf)(25);
//ans=pf(25);

注意，以上注释部分是等价的。第一条语句简单地调用函数f()，但它的执行过程可能和你想象的不太一样。函数名f首先被转换为一个函数指针，该指针指定函数在内存中的位置。然后，函数调用操作该函数，执行开始于这个地址的代码。第三条语句和前面两条语句效果是一样的。间接访问操作并非必需，因为编译器需要的是一个函数指针。

字符串常量

*("xyz"+1)
//"xyz"[1]

的结果作为右值就是y。

*"xyz"

的结果作为右值就是x。

操作符 ->

-> 前面的变量必须为指向结构的指针。所以：

typedef struct{
    int x;
    int y;
}Point;

Point p;
Point *a=&p;
Point **b=&a;

根据以上声明，则

b->x
b->a
*b->a
*b->x
b->a>x
(*b)->a

都是非法的。

第十四章 预处理器

宏

#define替换

将宏参数转换为一个字符串的技巧是使用 "#argument" ，其中argument是宏参数，如此argument将不会以变量而是字符串的形式表出。如：

#define PRINT(FORMAT,VALUE)  \
        printf("The value of "#VALUE" is "#FORMAT"",VALUE)
......
PRINT(%d,x+3);

输出：

The value of x+3 is 25

宏与函数

一般而言，宏非常频繁地用于执行简单的计算。因为宏相对于函数没有函数调用/返回的开销。比如getchar()就是用宏定义的。但是当程序长度过长时或需要用递归时，宏就不再实用。宏还有一个优点就是宏与类型无关。比如：

#define add(x,y) ((x)+(y))
//在那些对表达式求值的宏中，每个宏参数出现的地方都应该加上括号，并且在整个宏定义的两边也要加上括号。

其中x、y可以是int型，也可以是float型和long型等等等等。再一个：

#define MALLOC(n,type)  \
        ((type *)malloc((n)*sizeof(type)))
......
pi=MALLOC(25,int);
//=>pi=((int *)malloc((25)*sizeof(int)))

在这个例子中，函数无法实现type参数功能。但是，并不是说宏就没有副作用，当宏参数在宏定义中出现不止一次时，就很可能有副作用。比如：

#define MAX(x,y) ((x)>(y)?(x):(y))
......
x=5;
y=8;
z=MAX(x++,y++);
printf("x=%d y=%d z=%d",x,y,z);

输出为：

x=6 y=10 z=9

因为

z=MAX(x++,y++);
//=>z=((x++)>(y++)?(x++):(y++));

而函数则没有这个问题，因为函数参数只在函数调用时求值一次，它的结果值传给函数。

#undef

这条预指令用于移除一个宏定义。例子：

#include<stdio.h>
#define MAX 100
int main(int argc,char *argv[]){
    printf("%d ",MAX);
    #undef MAX
    int MAX=10;
    printf("%d",MAX);
    return 0;
}

输出为：

100 10

条件编译

#if constant-expression1
    statements1
#elif constant-expression2
    statements2
#else
    statements3
#endif

当constant-expression1为真时编译statements1，当constant-expression2为真时编译statements2，否则编译statements3。它和

if constant-expression1
    statements1
else if constant-expression2
    statements2
else
    statements3

相比优点在于后者全部都要编译进去，而前者只需要编译一部分。所以前者效率会更高。更多关于条件编译的知识请戳这里。

嵌套文件包含

嵌套#include文件的一个不利之处在于它使我们很难判断源文件之间真正的依赖关系，另一个不利之处在于一个头文件可能会被多次包含。如：

#include "x.h"
#include "y.h"

如果x.h和y.h中都包含了z.h这个头文件，那么z.h就被重复包含了。为了解决这个问题，可以这样做：

//在z.h头文件中
#ifndef _Z_H
#define _Z_H 1
//1可有可无
/*
*All the stuff that you want in the header file.
*/
#endif

注意预处理和正式编译的处理顺序

以下代码是错的：

#if sizeof(int)==2
    typedef long int32;
#else
    typedef int int32;
#endif

因为sizeof是在预处理器完成工作后而发挥作用的。而在预处理阶段无法处理sizeof等字段。

后记

《C与指针》这本书暂时先告一段落，毕竟第一遍看不能完全看懂也不能吸收全部精华。总的来说寒假虽然天天打游戏，但是总算做了点正事。寒假弯道虽没超车，但也幸好没翻车。