[C和指针]第二部分

K&R C:
int *
find_int (key,array,array_len)
int key;
int array;
int array_len;
{}
但不能省略函数的大括号，所以不支持函数原型声明。

为了与ANSI标准之前的程序兼容性，没有参数的函数的原型应该写成下面这样：
int func (void) ;

当程序调用一个无法见到原型的函数时，编译器便认为该函数返回一个整型值。所有函数都应该具有原型，尤其是那些返回值不是整形的函数。

可变参数
可以使用<stdarg.h>中的一组宏定义来操纵可参数。

用法：
（1）首先在函数里定义一具va_list型的变量，这个变量是指向参数的指针
（2）然后用va_start宏初始化变量刚定义的va_list变量，这个宏的第二个参数是省略号前最后一个有名字的参数。
（3）然后用va_arg返回可变的参数，va_arg的第二个参数是你要返回的参数的类型。如果函数有多个可变参数的，依次调用va_arg获取各个参数。
（4）最后用va_end宏结束可变参数的获取。

由于参数列表中的可变参数部分并没有原型，所以，所有作为可变参数传递给函数的值都将执行缺省参数类型提升（）相乘。这个乘法需要花费一定的时间和空间。现使用指针来实现同样的功能：
int array[10], *p;
for (p = array; p < array + 10; p++) {
*p = 0;
}
现在这个乘法出现在for语句的调整部分，1这个值必须与整型的长度相乘，然后现与指针相加，但这里存在一个重大区别：循环每次执行时，执行乘法运算的都是两个相同的数（1和4），结果，这个乘法只在编译时执行一次，程序在运行时并不执行乘法运算，所以在运行时所需要的指令就少一些。


最高效的数组访问：
#define SIZE 50
int x[SIZE];
int y[SIZE];
//数组拷贝
int main () {
register int *p1, *p2;
for (p1 = x, p2 = y; p1 < &x[SIZE];) {
*p1++ = *p2++;
}
}
结论：当你根据某个固定数目的增量在一个数组中移动时，不如使用指针变量将比使用下标产生效率更高的代码；声明为寄存器变量的指针通常比位于静态内存和堆栈中的指针效率更高；如果你可以通过测试一些已经初始化并经过调整的内容来判断循环是否该应该终止，那么你就不需要使用一个单独的计数器。

指针和数组
int a[5];
int *b;

声明一个数组时，编译器将根据声明所指定元素数量为数组保留内存空间，然后再创建数组名，它的值是一个常量，指向这段空间的起始位置。声明一个指针变量时，编译器只为这个指针本身保留内存空间，它并不为任何整型值分配内存空间，而且，指针变量并未初始化为指向现有的有意义的空间。所以 *a 是完全合法的，但表达式 *b 却是非法的。*b将访问内存中某个不确定的位置，或者导致程序终止，另外，表达式b++可以通过编译，但a++却不行，因为a的值是个常量。


数组参数
数组名的值就是一个指向数组第一个元素的指针，所以传递给函数的是一份该指针的拷贝。函数如果执行了下标引用，实际上是对这个指针执行间接访问操作，并且通过这种间接访问，函数可以访问和修改主调程序的源数组元素。

传址调用是通过传递一个指向所需元素的指针，然后在函数中对该指针执行间接访问操作实现对数据的访问，而作为参数的数组名是个指针，下标引用实际执行的就是间接访问，所以传递数组时“好像”体现了传址，但本身却是传值，那数组的传值行为表现在什么地方呢？传递给函数的是参数的一份拷贝（指向数组起始位置的指针的拷贝），所以函数可以自由地操作它的指针形参，而不必提心会修改对应的作为实参的指针。所以并不矛盾：所有的参数都是通过传值方式传递的。

传递一个数组时，正确的函数形参应该是怎样的？它是应该声明为一个指针还是一个数组？调用函数时实际传递的是一个指针。但为了使用程序员新手更容易上手一些，编译器也接受数组形式的函数形参，下面两个函数原型是相等的：
int strlen ( char * string);
int strlen ( char string[]);
这个相等性暗示指针和数组名实际上是相等的，但千万不要被它糊弄了，这两个声明确实相等，但只是在当前这个上下文环境中。哪个“更加准确”呢？答案是指针，因为实际上是个指针，而不是数组，同样，表达式sizeof string的值是指向字符的指针的长度，而不是数组的长度：
int size1 ( int * a){
return sizeof a;
}
int size2 ( int a[]){
return sizeof a;
}
int main () {
int a[5];
printf ("%d\n", sizeof a);//20
printf ("%d\n",size1(a));//4
printf ("%d\n",size2(a));//4
}
现在你应该清楚为什么函数原型中的一维数组形参无需写明它的元素数目（如果是多维数组，则也只能省略第一维的大小），因为函数并不为数组参数分配内存空间。形参只是一个指针，它指向的是已经在其他地方分配好的内存的空间，它可以与任何长度的数组匹配。另一方面，这种实现方法使函数无法知道数组的长度，如果函数需要知道数组的长度，它必须作为一个显示的参数传递给函数。

不完整的初始化
int vector[5] = { 1, 2, 3, 4, 5, 6 };
int vector[5] = { 1, 2, 3, 4 };
第一个声明是错误的，我们没有办法把6个整型值装到5个整型变量中去，但第二个声明是合法的，最后一个元素初始化为0。另外，也只能省略最后元素的值，不能省略中间的。

自动计算数组长度
int vector[] = { 1, 2, 3, 4 };
如果声明中并未给出数组的长度，编译器就把数组的长度设置为刚好容纳所有的初始值的长度。

字符数组的初始化
char string1[] = { 'H', 'e', 'l', 'l', 'o', 0 };
char string2[] = "Hello";
第二种看上去是一个字符串常量，实际上并不是（只是一个初始化列表），它只是第一个声明的另一种写法。那什么情况下"Hello"是一个字符串常量呢？要根据它所处的上下文来区分：当用于初始化一个字符数组时，它就是一个初始化列表，在其他任何地坟，它都表示一个字符串常量。

char string1[] = "Hello";
char *string2 = "Hello";
这两个初始化看上去很像，但它们具有不同的含义。第一个初始化一个字符数组的元素，而后者则是一个真正的字符串常量，这个指针变量被初始化为指向这个字符串常量的存储位置， 并且这个位置的内容不能被修改 ：


多维数组
多维数组在内存分配上与一维数组一样，在物理上没有区别，也是连续的，只是多维数组在逻辑上将元素划分为多个逻辑单位。

int matrix[6][10];
int *mp;
matrix[3][8] = 38;
matrix[3][9] = 39;
matrix[4][0] = 40;
mp = &matrix[3][8];
printf ("First value is %d \n", *mp);//38
printf ("Second value is %d \n", *++mp);//39
printf ("Third value is %d \n", *++mp);//40
这个例子使用一个指向整型的指针遍历存储了一个二维整型数组元素的内存空间，这个技巧被称为压扁数组，它实际上是非法的，因此从某行移到下一行后就无法回到包含第1行的那个子数组，尽管通常没有问题，但有可能的话还是应该避免这样使用。

多维数组名：
int matrix[3][10];
matrix可以看作是一个一维数组，包含3个元素，只是每个元素又是包含了10整型元素的数组。matrix这个名字是一个指向它第1个元素的指针，所以 matrix 是一个指向一个包含 10 个整型元素的数组的指针 。

matrix[1][5] == *(*(matrix + 1) + 5) == *(matrix[1] + 5)
matrix 指向第一行，(matrix+1)指向第二行，*(matrix+1)代表第二行元素（第二维数组），既然*(matrix+1)又是一个数组，所以该表达式又代表了(matrix+1)指向的第二行子数组的首元素的地址，所以(*(matrix+1)+5)表示在(matrix+1)指向的第二行子数组中移动到第6个元素位置上，所以*(*(matrix+1)+5)代表了该位置上的元素。

int matrix[3,10];
在其他语言中表示二维数组，但在C中不是的，它是一个逗号表达式，最终的结果为matrix[10]，而不是二维数组了

int vector [10], *vp = vector;
int matrix[3][10], *mp = matrix;
第一个表达式合法，vp与vector具有相同的类型，都是指向整型的指针；第二个声明非法，因为matrix并不是一个指向整型的指针，而是一个指向整型数组的指针，正确写法如下：
int (*p)[10]= matrix;
(*p)[10]由于间接访问*的优先级低于数组下标访问，所以使用括号，这样就使 *p[10]从数组类型转换成了一个指针类型，p是一个指向拥有10个整型元素的数组的指针，使用它可以在matrix数组中一行一行的移动。上述表达式指向了matrix数组的第一行。
如果你需要一个指针逐个访问整型元素而不是逐行在数组中移动，你应该这样：
int *pi=&matrix[0][0]; // 第一个元素的地址
int *pi=matrix[0]; // 第一个元素的地址也就是数组名
上面两个声明都创建了一个简单的整型指针，并以两种不同的方式进行初始化，指向matrix的第1个整型元素。

如果你打算在指针上执行任何指针运算，应该避免这种类型的声明：
int (*p)[] = matrix;
p仍然是一个指向整型数组的指针，但 数组的长度没有，当与某个整型运算时，它的值将根据空数组来进行调整，即与零乘，这不是我们想要的。有些编译器要以捕捉到这类错误，但有些编译器却不能。

int matrix[3][10];
如果传递给一个函数，则函数的原型声明可以有以下两种：
void func ( int (*p)[10]);
void func ( int p[][10]);
但决不能是：
void func ( int **p);
因为**p的类型为指向指针的指针，而(*p)[10]表示指向一个具有10元素的数组的指针。

多维数组的初始化可以像一维数组那样：
int matrix[2][3] = { 1, 2, 3, 4, 5, 6 };
但Java不允许这样

char const * keyword[] = { "do", "for", "if", "register", "return",
"switch", "while" };
char const **kwp = keyword;
keyword是一个 指针数组 ，数组名keyword是一个二级指针（每个元素都是指针），其内存结构如下：


char const keyword[][9] = { "do", "for", "if", "register", "return",
"switch", "while" };
其内存结构如下：

C语言并没有的字符串数据类型，因为字符串是以字符串常量的形式出现或者存储于字符数组中。个字符串不为空时才进行查找，如果s2为空，返回null
*/
if (*s2 != '\0') {
/*
** 查找s2在s1中第一次出现的位置
*/
current = strstr (s1, s2);

/*
** 每次找到字符串时，指向它的起始位置，然后查找该字符串下一个匹配位置。
*/
while (current != NULL) {
last = current;
current = strstr (last + 1, s2);
}
}
/*
** 返回指向我们找到的最后一次匹配的起始位置的指针
*/
return last;
}

查找一个字符串前缀：
size_t strspn ( char const *str, char const *group);
返回str起始部分匹配group中任意字符的字符数。例如，如果group包含了空格、制表符等空白字符，这个函数将返回str起始部分空白字符数目。下面的代码将计算一个指向字符串中第一个非空白字符的指针：
char * ptr = buffer + strspn(buffer, "\n\r\f\t\v");

size_t strcspn ( char const *str, char const *group);
strcspn正好与strspn相反，它对str字符串起始部分中不与group中任何字符匹配的字符进行计数。
示例：
char buffer[] = "25,142,330,Smith,J,239-4123";
int len1, len2;
len1 = strspn (buffer, "0123456789");
printf ("%d\n", len1);//2
len2 = strcspn (buffer, "ith");
printf ("%d\n", len2);//13

查找标记：
char * strtok ( char * str, const char *set)
strtok 函数使用set字符串中的标记将字符串str分隔成不同的独立部分，每次可以返回这个独立部分。 strtok 函数找str中的标记后，使用NUL替换，并返回一个指向标记前的邻近字符串指针。如果函数的第一个参数str不为NULL，函数将查找字符串的第一个标记，如果为NULL，函数就从上一次查找的位置后开始查找标记。通常，第一次调用时传递一个字符串指针，以后，这个函数被重复调用（第一参数传递NULL），直到它返回NULL：
void print_tokens ( char *line) {
static char whitespace[] = " ,";
char *token;
for (token = strtok (line, whitespace); token != NULL; token = strtok (NULL,
whitespace)) {
printf ("Next token is %s\n", token);
}
}
int main () {
char buffer[] = "a b,c";
print_tokens(buffer);
}
由于strtok函数保存了处理过的函数的局部状态信息，所以
printf ("%c\n", memchr (a, 'b', 3) == NULL ? '0'
: *( char *) memchr (a, 'b', 3));//b

memset 函数把从aga vck r length个字节都设置为字符值ch，例如：
memset (buffer, 0, SIZE);
把buffer的前个字节都初始化为0。