c数组小记

一维数组

1.数组名

int b[10];
int *c;

c = b;/*起作用相当于下一句*/
c = &b[0];

数组名是的值是一个指针常量，数组第一个元素的地址。
b指向数组的第一个元素，其值为常量，不能被修改。
2. 下标引用

int array[10];
int *ap = array + 2;
/*等价于*/
ap = &array[2];
ap+8;  /*相当于array+8或 &array[8]*/
ap[6];/*相当于array[8] 或 *(ap+6) */
ap[-1];/*偏移量为-1，得到前面一个元素即array[1]*/
2[array];/*相当于于*(array + 2)*/

指针进行加法运算时会对2进行调整，指针ap指向array[2]
在数组中一次一步移动时，使用指针相对于下标访问更有效。
3.寄存器指针

void Try()
{
	int x[50];
	int y[50];
	register int* p1, * p2;
	register int i;

	for (i = 0, p1 = x, p2 = y; i < 50; i++)
		*p1++ = *p2++;
}

使用寄存器指针就不必复制指针值。

void Try1()
{
	int x[50];
	int y[50];
	register int* p1, * p2;
	for (p1 = x, p2 = y; p1 < &x[50];)
		*p1++ = *p2++;
}

for循环中省去自加操作，效率更高。
4.上述小结
某个固定数目的增量在一个数组中移动时，指针标量比下标产生效率更高的源代码。
声明为寄存器变量夫人指针通常比位于静态内存和堆栈中的指针效率更高。
尽可能通过测试一些已初始化并经过调整的内容来判断循环是否终止。
运行求值的表达式较之&array[size]的常量表达式代价更高。
5.数组和指针

int a[5];
int *b;

*a是合法
*b是非法的
b++合法
a++非法，因为a是常量
6.声明数组参数
一维数组无需写明他的数组元素个数，函数并不为数组参数分配内存空间，形参只是一个指针，它指向已经分配好的内存空间，可以匹配任何长度的数组。
static声明的静态数组只初始化一次，在程序开始之前，若数组未被初始化，数组的元素初始值会自动设置为零。
自动变量在缺省情况下是未初始化的，若在声明中给出了初始值每当执行流进入自动变量声明所在的作用域时，会被一条隐式的赋值语句初始化。

int  vector[] = {1,2,3,4,5}；
char message[] = "hello";

编译器会自动计算数组的长度

int x[10];
int y[3][8];
*（y + 1）+ 5; /*为y[1][5]的地址*/
*(*(y+1)+5);/*取y[1][5]中的值*/

x为指向x数组第一个元素的地址
y为指向y数组包含8个元素的的数组指针

int vector[10], *vp = vector;
int matrix[3][10], *mp = matrix;
int (*p)[10];

第一个声明合法，vp指向数组第一个元素的数组
第二个声明非法，matrix是一个指向整型数组的指针
第三个声明合法，p是指向整型数组的指针

int *pi = &matrix[0][0];
int *pi = matrix[0];

增加pi指针值会使它指向下一个整型元素

void fun(int (*p)[10]);
void fun1(int mat[][10]);

形参为二维数组，第二个声明第一维的长度并不需要，需要第二个及多维数组的后面各维长度才能对下标进行求值。

int four_dim[2][2][3][10] = {
	{
		{
			{100}
		}
	},
	{
		{
			{200}
		}
	}
};

上述四维数组将元素[0][0][0][0]初始化为100，将元素[1][0][0][0]初始化为200.
7.指针数组

char const keyword[10];
int a = sizeof(keyword) / sizeof(keyword[0]);

sizeof(keyword)获得整个数组所占用的字节数，sizeof(keyword[0])获得数组每个元素所占用的字节数，a返回的是数组元素的个数。
使用矩阵形式的数组，每一行长度都固定为刚好容纳最长的关键字，但是不需要任何指针；使用指针形式的数组，根据每个字符串常量占据的内存空间只是它本身的长度。当数组内各个字符串长度千差万别时，建议使用指针型数组。
8.小结
数组下标优先级高于*（）优先级
只要有可能，函数的指针形参都应该声明为const