第8章 数组

学习笔记

• 2[array]与array[2]是相同的，因为2[array]可以拆开为*(2 + array)，但是2[array]会大大的影响程序的可读性

/* code 1 */
int array[10], a;
for(a = 0; a < 10; a += 1)
	array[a] = 0;
/* code 2 */
int array[10], *ap;
for(ap = array; ap < array + 10; ap++)
	*ap = 0;

• 代码片段1中，为了对下标表达式求值，编译器在程序中插入指令，取得a的值，并把它与整型的长度（也就是4）相乘。这个乘法需要花费一定的时间和空间；代码片段2中，尽管不存在下标，但是还是存在乘法运算ap++，1每次与整型的长度相乘，然后再与指针相加。但是循环每次执行时，执行乘法的运算都是两个相同的数。因此，这个乘法只在编译时执行一次。这个例子说明了指针比下标更有效的场合
• 当你根据某个固定数目的增量在一个数组中移动时，使用指针变量将比使用下标产生效率更高的代码。当这个增量是1并机器具有地址自动增量模型时，这点表现得更为突出。声明为寄存器变量的指针通常比位于静态内存和堆栈中的指针效率更高

char message1[] = "Hello";
char *message2 = "Hello";

• 这两个初始化看上去很像，但它们具有不同的含义。前者初始化一个字符数组的元素，而后者则是一个真正的字符串常量。这个指针变量被初始化为指向这个字符串常量的存储位置

matrix[4, 3]

• 逗号操作符首先对第一个表达式求值，但随即丢弃这个值。最后的结果时第二个表达式的值。因此，这个表达式与matrix[3]是相等的
• 下标的优先级高于间接访问

书后练习

问题1

根据下面给出的声明和数据，对每个表达式进行求值并写出它的值。在对每个表达式进行求值时使用原先给出的值（也就是说，某个表达式的结果不影响后面的表达式）。假定ints数组在内存中的起始位置是100，整型值和指针的长度都是4个字节。

int ints[20] = {
	10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
	110, 120, 130, 140, 150, 160, 170, 180, 190, 200
};
// Other declarations
int *ip = ints + 3;

表达式	值	表达式	值
ints	100	ip	112
ints[4]	50	ip[4]	80
ints + 4	116	ip + 4	128
*ints + 4	14	*ip + 4	44
*(ints + 4)	50	*(ip + 4)	80
ints[-2]	非法	ip[-2]	20
&ints	100	&ip	非法
&ints[4]	116	&ip[4]	128
&ints + 4	116	&ip + 4	非法
&ints[-2]	非法	&ip[-2]	104

问题5

指针在效率上可能强于下标，这是使用它们的动机之一。那么什么时候使用下标是合理的，尽管它的效率上可能有所损失？
回答：经常，一个程序80%的运行时间用于执行20%的代码，所以其他80%的代码的语句对效率并不是特别敏感，所以使用指针获得的效率上的提高抵不上其他方面的损失

问题8

下面的声明取自某个源文件：

int a[10];
int *b = a;

但在另一个不同的源文件中，却发现了这样的代码：

extern int *a;
extern int b[];
int x, y;
...
x = a[3];
y = b[3];

请解释一下，当两条赋值语句执行时会发生什么？（假定整型和指针的长度都是4个字节）
回答：在第一个赋值中，编译器认为a是一个指针变量。所以它提取存储在那里的指针值，并加上12，然后对这个结果执行间接访问操作。但a实际上是整型数组的起始位置，所以作为指针获得的这个值实际上是数组的第一个整型元素。它与12相加，其结果解释为一个地址，然后对它进行间接访问。作为结果，它或者将提取一些任意内存位置的内容，或者由于某种地址错误而导致程序失败。
在第二个赋值中，编译器认为b是个数组名，所以它把12加到b的存储地址，然后间接访问操作从那里获得值。事实上，b是个指针变量，所以从内存中提取的后面三个字实际上是从另外的任意变量中取得的。这个问题说明了指针和数组虽然存在关联，但绝不是相同的。

/* file1.c */

int a[10] = {1,2,3,4,5,6,7,8,9,10};
int *b = a;

/* file2.c */

#include<stdio.h>
#include"file1.c"

extern int a[];
extern int *b;

int main(){
    int x = a[3], y = b[3];
    printf("%d\n%d\n",x, y);
    return 1;
}

问题12

C的数组按照行主序存储。什么时候需要使用这个信息？
回答：当执行任何按照元素在内存中出现的顺序对元素进行访问的操作时。

问题17

解释下面两种const关键字用法的显著区别所在。

void function( int const a, int const b[] ) {

回答：第一个参数是个标量，所以函数得到值的一份拷贝。对这份拷贝的修改并不会影响原先的参数，所以const关键字的作用并不是防止原先的参数被修改；第二个参数实际上是一个指向整型的指针。传递给函数的是指针的拷贝，对它进行修改并不会影响指针参数本身，但函数可以通过对指针执行间接访问修改调用程序的值。const关键字用于防止这种修改。

编程练习2

美国联邦政府使用下面这些规则计算1995年每个公民的个人收入所得税：

如果你的含税收入大于	但不超过	你的税额为	超过这个数额的部分
$0	$23350	15%	$0
23350	56550	$3502.50+28%	23350
56550	117950	12798.50+31%	56550
117950	256500	31832.50+36%	117950
256500	-	81710.50+39.6%	256500

为下面的函数原型编写函数定义：

float single_tax( float income );

参数income表示应征税的个人收入，函数的返回值就是income应该征收的税额

#include<float.h>

static float incomes[] = {0, 23350, 56550, 117950, 256500, FLT_MAX};
static float tax[] = {0, 3502.5, 12798.5, 31832.5, 81710.5};
static float percentage[] = {.15, .28, .31, .36, .396};

float single_tax(float income){
    int i;
    for(i = 1; income >= incomes[i]; i++)
        ;
    i--;
    return tax[i] + percentage[i] * (income - incomes[i]);
}

编程练习5

如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘，其结果将是另一个x行z列的矩阵C。这个矩阵的每个元素是由下面的公式决定的：
$$C_{i,j}=\sum _{k=1}^y{A}_{i,k}\times B_{k,j}$$
例如：
$$\left[\begin{array}{cc}2& -6\\ 3& 5\\ 1& -1\end{array}\right]\times \left[\begin{array}{cccc}4& -2& -4& -5\\ -7& -3& 6& 7\end{array}\right]=\left[\begin{array}{cccc}50& 14& -44& -52\\ -23& -21& 18& 20\\ 11& 1& -10& -12\end{array}\right]$$
结果矩阵中14这个值是通过$2\times -2$加上$-6\times -3$得到的。
编写一个函数，用于执行两个矩阵的乘法。函数的原型应该如下：

void matrix_multiply( int *m1, int *m2, int *r, int x, int y, int z );

m1是一个x行y列的矩阵，m2是一个y行z列的矩阵。这两个矩阵应该相乘，结果存储于r中，它是一个x行z列的矩阵。记住，你应该对公式做些修改，以适应C语言下标从0而不是1开始这个事实！

#include<stdio.h>
#include<stdlib.h>

/*
 * m1 x y
 * m2 y z
 * r x z
 * */
void matrix_multiply(int *m1, int *m2, int *r, int x, int y, int z){
    /* 按照矩阵r按行的存储顺序进行计算 */
    for(int i = 0; i < x; i++){
        for(int j = 0; j < z; j++){
            *r = 0;
            /* 确定相乘矩阵的行和列 */
            int *ptr1 = m1 + y * i;
            int *ptr2 = m2 + j;
            for(int k = 0; k < y; k++){
                *r += *ptr1 * *ptr2;
                ptr1++;
                ptr2 += z;
            }
            r++;
        }
    }
}

int main(int argc, char *argv[]){
    int m1[] = {2,-6,3,5,1,-1};
    int m2[] = {4,-2,-4,-5,-7,-3,6,7};
    int res[12];
    matrix_multiply(m1, m2, res, 3, 2, 4);
    for(int i = 0; i < 12; i++){
        printf("%d\t", res[i]);
        if((i + 1) % 4 == 0)
            printf("\n");
    }
    return EXIT_SUCCESS;
}