数组与指针

一、数组的初始化

　　1、当初始化列表中的值少于数组元素个数时，编译器会把剩余的元素都初始化为0；

　　2、如果初始化数组时省略方括号中的数字，编译器会根据初始化列表中的项数来确定数组的大小；

　　3、对于数组中个数的多少，有一个比较不容易出错的方法 - sizeof () 的使用；

　　e.g. : int nums[] = {31, 28, 31, 30};

　　　　  int count = sizeof nums / sizeof nums[0]; //计算数组中的元素个数

　　【sizeof ()：给出运算对象的大小，以字节为单位。在上述的语句中，sizeof nums 是整个数组的大小，sizeof nums[0] 是数组中一个元素的大小。】

　　4、C99 中可以初始化指定的数组元素。

int arr[7] = {1, 2, [4] = 23, 8, [1] = 12}

　　上述语句的结果为：arr[0] = 1, arr[1] = 12, arr[2] = 0, arr[3] = 0, arr[4] = 23, arr[5] = 8, arr[6] = 0。

 　　5、C 不允许把数组作为一个单元赋给另外一个数组，除初始化以外也不允许使用花括号列表的形式进行赋值。　　

#define SIZE 5
int main (void)
{
    int oxen[SIZE] = {5, 3, 2, 8};
    int yaks[SIZE] ;
    
    yaks = oxen; /*不允许*/
    yaks[SIZE] = oxen[SIZE]; /*数组下标越界*/
    yaks[SIZE] = {5, 3, 2, 8}; /*不起作用*/          
}   

二、多维数组的理解 

　　1、二维数组的理解

float rain[5][12];    //内含5个数组元素的数组，每个数组元素内含12个float类型的元素

　　换句话说，rain中每个元素本身都是一个内含12个float 类型值的数组。

　　2、三维数组的理解

int box[10][20][30];

　　对于box，其理解方式有：1，box内含10个元素，每个元素是内含20个元素的数组，这20个数组元素中的每个元素是内含30个元素的数组；2，把box想像成有10个二维数组（每个二维数组都是20行30列）堆叠起来。

　　3、多维数组的理解

　　与1、2的内容相类似。

三、指针 & 数组

　　1、指针的值是其指向对象的地址。地址的表示方式依赖于计算机内部的硬件。

　　2、指针前使用 ‘ * ’ 运算符可以得到该指针所指向对象的值。

　　3、指针加1，指针的值递增其所指向类型的大小（以字节为单位）。

四、函数 & 数组 & 指针

　　1、声明数组形参

　　对于函数原型中的数组形参的声明，下面的几种原型是等价的。

int sum (int *ar, int n);
int sum (int *, int n);
int sum (int ar[], int n);
int sum (int [], int n);

　　但是，在函数定义的时候不能省略参数名，下面的几种函数定义是等价的。

int sum (int *ar, int n){
    //函数主体
}

int sum (int ar[], int n){
    //函数主体
}

　　2、‘ * ’运算符与‘ ++ ’ / ' -- '运算符的结合

total += *star++; //先‘递增’后指向
total += (*star)++; //先指向后递增

　　对于上述语句，‘ * ’运算符与‘ ++ ’运算符的优先级相同，但是结合律是从右到左，所以先计算start++，之后再计算*start，先‘递增’后指向。使用后缀形式（start++，而不是++start）意味着先把指针指向位置上的值加到total上，然后再递增指针；如果使用前缀形式（++start，而不是start++），意味着要先递增指针，之后把指针指向位置上的值加到total上。

五、指针的几种操作

int urn[5] = { 100, 200, 300, 400, 500 }
int * ptr1, *ptr2, *ptr3;

　　1、赋值

ptr1 = urn;    //将一个地址赋给指针
ptr2 = &urn[2];    //将一个地址赋给指针

　　2、解引用

printf("ptr1 = %p, *ptr1 = %d, &ptr1 = %p
", ptr1, *ptr1, &ptr1);

　　解引用 - “ *ptr1”。给出指针指向的地址上存储的值。

　　3、取址

printf("ptr1 = %p, *ptr1 = %d, &ptr1 = %p
", ptr1, *ptr1, &ptr1);

　　取址 - “ &ptr1”。指针也有自己的地址，‘ & ’运算符给出的是指针本身的地址。

　　4、指针与整数相加

ptr3 = ptr1 + 4;    //指针加法

　　' ptr1 + 4 ' 等价于 &urn[4] 。

　　5、递增指针

ptr1++;    //指针递增

　　‘ ptr1++ ’ 等价于ptr1的值加上4（假设系统中 int 数据为4字节），pte1 指向 urn[1] 。

　　6、指针减去一个整数

printf("ptr3 - 2 = %p
", ptr3 - 2);

　　整数将乘以指针指向类型的大小（以字节为单位），然后用初始地址减去乘积。

　　7、递减指针

ptr2--;    //指针递减

　　8、指针求差

printf("ptr2 - ptr1 = %td
", ptr2 - ptr1);

　　通常两个指针指向同一个数组的不同元素，通过计算求出两元素之间的距离。差值的单位与数组类型的单位相同。如果 ptr2 - ptr1 = 2，则意味着两个指针所指向的元素之间相差着两个 int ，而并不是两个字节。

　　9、比较

　　使用关系运算符进行比较，前提是两者都是指向相同类型的对象。

六、 const 修饰符的使用　

　　1、对形参使用 const

int sum (const int ar[], int n);  /*函数原型*/

int sum (const int ar[], int n){
    //函数体
}

　　上述的 const 修饰符告知编译器：sum 函数不可以修改 ar 指向的数组中的内容。如果在 sum 函数中使用的类似于 ar[i]++的表达式，编译器会很容易地检测到错误。

　　这里只用的 const 修饰符并不是要求原数组是常量，而是该函数在处理数组时将其看做是常量，不可更改。

　　一般而言，如果函数需要修改数组，在声明数组形参时不使用 const 修饰符；如果编写的函数不用修改数组，在声明数组形参时使用 const 修饰符。

 　　2、const 修饰符的其他内容

　　【 const 数组】

#define SIZE 3
...
const int data[SIZE] = {2, 4, 7};
...
data[2] = 5;    //编译错误

　　【 const 指针】 

double index[3] = {1.1, 2.3, 4.5};
const double * pd = index;
...
*pd = 3.8;  //不允许
pd[2] = 9.0;  //不允许
index[2] = 9.0; //允许，index 未被限定

　　需要注意的是，可以让 pd 指向别处：' pd ++ ;' 是允许的。

　　【其他】

　　把 const 数据或非 const 数据的地址初始化为指向 const 的指针或为其赋值是合法的。

double rates [4] = {88.99, 100.12, 4.98, 76.45};
const double locked[3] = {1.2, 3.5, 7.9};
const double * pc = rates;    //有效
pc = locked;    //有效
pc = &rates[2];    //有效

　　只能把非 const 数据的地址赋给普通指针。

double rates [4] = {88.99, 100.12, 4.98, 76.45};
const double locked[3] = {1.2, 3.5, 7.9};
double * pc = rates;    //有效
pc = locked;    //无效
pc = &rates[2];    //有效

　　C 标准规定，使用非 const 修饰符修改 const 数据，导致的结果是未定义的。【不应该把 const 数组名作为实参传递给相应形参为非 const 数组名的函数。】

 　　可以声明并初始化一个不能指向别处的指针，关键是 const 修饰符的位置。

double rates [4] = {88.99, 100.12, 4.98, 76.45};
double * const pc = rates;    //pc 指向数组的开始
pc = &rates[1];    //无效，pc 不允许指向别处
*pc = 99.9;    //有效，更改 rates[0] 的值

　　可以使用 const 修饰符两次，使得指针即不能更改其所指向的地址，也不能更改其指向的地址上的值。

double rates [4] = {88.99, 100.12, 4.98, 76.45};
const double * const pc = rates;    //pc 指向数组的开始
pc = &rates[1];    //无效，pc 不允许指向别处
*pc = 99.9;    //无效，不允许更改 rates[0] 的值

 七、指针与多维数组

　　1、简单示例

int zippo[4][2];
/*
zippo  --  二维数组首元素的地址（每个元素都是内含两个 int 类型元素的一维数组）
zippo + 2 -- 二维数组的第3个元素（即一维数组）的地址
*(zippo + 2) -- 二维数组的第3个元素（即一维数组）的首元素（一个 int 类型的值）的地址
*(zippo + 2) + 1 -- 二维数组的第3个元素（即一维数组）的第2个元素（一个 int 类型的值）的地址
*(*(zippo + 2) + 1) -- 二维数组的第3个一维数组的第2个 int 类型的值，也就是 zippo[2][1]
*/

　　2、相关的指针数组

int (* pz) [2];  //pz指向一个内含两个 int 类型值的数组
int * pzx[2];  //pax是一个内含两个指针元素的数组，每个元素都指向 int 的指针

　　3、指针的兼容性

　　【两个不同类型的指针之间不可以相互赋值】

　　4、需要处理二维数组的函数中的形参的声明

...
#define ROWS 3
#defien COLS 4
...
void sum_rows (int ar[][COLS], int rows);  //空的方括号表明 ar 是一个指针
void sum_rows (int (*ar) [COLS], int rows);
void sum_cols (int [][COLS], int );  //可以，省略形参名
int sum2d(int (*ar) [COLS], int rows);  //另一种语法

八、复合字面量【C99 新增】

　　字面量：除符号常量之外的常量。

　　1、示例

　　【pre】5 -- int 类型字面量；2.3 -- double 类型字面量；'Y' -- char 类型字面量；"elephant" -- 字符串字面量。

　　【新增 - 数组】对于数组，复合字面量类似于数组初始化列表，前面是用括号括起来的类型名。

double diva [2] = {2, 4};    //普通的数组声明
(int [2]) {2, 4};    //复合字面量

　　【去掉声明中的数组名，留下的 int [2] 即是复合字面量的类型名。】

　　2、相关用法

　　【与有数组名的数组初始化一样，同样可以省略数组大小，编译器会自动计算数组当前的元素个数。】

(int []) {10, 20, 40}    //内含3个元素的复合字面量

　　【复合字面量是匿名的，必须在创建的同时去使用。常见的用法是指针记录地址。】

int *pt1;
pt1 = (int [2]) {10, 20};    //复合字面量的类型名也代表着首元素的地址，*pt1 = 10，pt[1] = 20

　　【可以把复合字面量作为实际参数传递给带有匹配形式参数的函数。】

int sum (const int ar[], int n);
...
int toal3;
total3 = sum((int []) {4, 4, 4, 5, 5, 5}, 6);//第一个实参：内含6个 int 类型值的数组。把信息传入函数前不必先创建数组，此为复合字面量的典型用法