实验五 数组和指针

#include <stdio.h> 

const int N=3;
int main() {
    int a[N] = {1, 2, 3};  
    int i;
    
    printf("通过数组名及下标直接访问数组元素:\n");
    for(i=0; i<N; i++)
        printf("%d: %d\n", &a[i], a[i]);
        
    printf("通过地址间接访问数组元素:\n");
    for(i=0; i<N; i++)
        printf("%d: %d\n", a+i, *(a+i));

    return 0;
} 

思考一：数组元素在内存中是连续存放的，因为从程序运行的结果可知，数组内相邻元素的地址都差4，在本代码中实际上4代表了一个对应的数据所需的字节数，整型需要四个字节。、

思考二：a+i和&a[i]的访问方式等价，都表示数组元素a[i]的地址；*(a+i)和a[i]访问方式上等价，都表示数组元素a[i]。其中a[i]可以算是直接访问的形式，而*(a+i)则可算作间接访问。

 

实验二：

 

#include <stdio.h>
const int LINE = 2;
const int COL = 3;

int main() {
    int a[LINE][COL] = {1,2,3,4,5,6};  
    int i,j;
    
    printf("通过数组名及下标直接访问数组元素:\n");
    for(i=0; i<LINE; i++)
        for(j=0; j<COL; j++)
            printf("%d: %d\n", &a[i][j], a[i][j]);
        
    printf("通过地址间接访问数组元素:\n");
    for(i=0; i<LINE; i++)
        for(j=0; j<COL; j++)
            printf("%d: %d\n", a[i]+j, *(a[i]+j));
    
    printf("二维地址中a+i表示的地址:\n");
    for(i=0; i<LINE; i++) 
        printf("a + %d: %d\n", i, a+i);
    
    return 0;
} 

 

 

思考一：代码中通过循环嵌套来输出二维数组的所有元素，其中以行的顺序为大循环，以列的排序为小循环，所以最终输出的元素是按照先行后列的顺序输出的。而在程序结果图中我们可以看到每个相邻元素地址之间的差值都为4，由此可见，二维数组在内存中是按行存放的。

思考二:a[i]+j和&a[i][j]都表示二维数组元素a[i][j]的地址； *(a[i]+j)和a[i][j]都表示二维数组元素a[i][j]。对于a[i]+j的形式，我们可以将a[i]看作是第i行数组的首地址，此时a[i][j]看作为第i行的一维数组，此时在运用地址的加法即可得出上述结论。

思考三：对于二维数组a[2][3]，a和&a[0]都表示二维数组第0行的地址，a+1和&a[1]都表示二维数组第1行的地址。首先在普遍的程序编译工具中，默认将二维数组每行的首个元素的地址作为行的地址。其次，若将一整行数组元素看成一个单位的元素，则从一维数组的角度看，a是该数组的首地址，同理可以实施地址的加法运算。

 

实验三：

 

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

const int N=3;

int main() {
    int a[N];
    int *p,i;
    
    // 通过指针变量p，完成数组元素输入
    for(p=a; p<a+N; p++)
        scanf("%d", p);
    
    // 过指针变量p，完成数组元素输出
    for(p=a; p<a+N; p++)
        printf("%d ", *p);
    printf("\n");
    
    p = a;
    //通过指针变量p，完成数组元素输入
    for(i=0; i<N; i++)
        scanf("%d", p+i); 
        
    // 通过指针变量p,完成数组元素输出
    for(i=0; i<N; i++)
        printf("%d ", *(p+i));
    printf("\n"); 

    return 0;
}  

 

思考一：指针变量p在使用时指向确定的地址。在每个for循环的开始，指针变量p都指向了一维数组首地址a指向的元素。

思考二：line12-13以及line16-17执行完后，指针变量p都指向了a[2]对应的数组元素。

思考三：line22-27执行完后，指针变量p指向了一维数组首地址a指向的元素；line26-line27执行完后，指针变量p也指向了一维数组首地址a指向的元素。

思考四：指针变量以间接访问形式访问一维数组时，可以不用改变自身所存放的地址；而如果用直接访问形式去访问一串数组的话，指针变量必须通过自增或自减改变自身存放的地址。所以，我们在使用指针变量访问数组时，要注意指针变量的初始值，而通过间接访问法我们可以避免由于指针变量的改变而引发的一些问题。

 

实验4：

 

#include <stdio.h> 

int main() {
    int a[2][3] = {1,2,3,4,5,6};
    int i,j;
    int *p;  // p是指针变量，存放int型数据的地址 
    int (*q)[3]; // q是指针变量，存放包含有3个元素的一维数组的地址
    
    // 通过指针变量p间接访问，输出二维数组a的元素值
    for(p=a[0]; p<a[0]+6; p++)
        printf("%d ", *p);
    printf("\n");
    
    // 通过行指针变量q间接访问，输出二维数组a的元素值 
    for(q=a; q<a+2; q++)
        for(j=0; j<3; j++)
            printf("%d ", *(*q+j));
    printf("\n");
    

    return 0;
}  

 

思考一：程序源代码中LINE11可以改成“for(p=&a[0][0]; p<&a[0][0] + 6; p++)”的形式，因为a[0]可以看作为二维数组第0行的地址，每行的地址默认为首个元素的地址，所以理论上，a[0]和a[0][0]的地址是一样的。

思考二：line18中，，“*q+j”中的q是指针变量，存放包含有3个元素的一维数组的地址，所以*q指向特定的一维数组中某个元素对应的地址，在二维数组中则指向特定行的行地址。而在二维数组中j就代表了具体的列地址。因此，“*q+j”代表了二维数组中一个具体元素的地址*(*q+j)则通过地址访问二维数组中的一个具体元素。

思考三：指向数组元素的指针变量p可以在循环中通过自增或自减输出二维数组中的所有元素；指向一维数组的指针变量q存放的是一维数组的地址，所以在二维数组中往往存放的是行地址(即行指针变量)。故需要两重循环，才能藉此输出二维数组的所有元素。

思考四：答案为：A,B,C,D,E,F,G

 

实验五：

 

#include  <stdio.h>

const int N=5;

int binarySearch(int x[], int n, int item); // 函数声明 

int main() {
    int a[N]={2,7,19,45,66};
    int i,index, key;
    
    printf("数组a中的数据:\n");
    for(i=0;i<N;i++)
       printf("%d ",a[i]);
    printf("\n");
    
    printf("输入待查找的数据项: ");
    scanf("%d", &key);
    
    // 调用函数binarySearch()在数组a中查找指定数据项key,并返回查找结果给index
    // 补足代码① 
    // ×××
    index=binarySearch(a,N,key);
    if(index>=0) 
        printf("%d在数组中，下标为%d\n", key, index);
    else
        printf("%d不在数组中\n", key); 
   
   return 0;
}

//函数功能描述：
//使用二分查找算法在数组x中查找特定值item，数组x大小为n 
// 如果找到，返回其下标 
// 如果没找到，返回-1 
int binarySearch(int x[], int n, int item) {
    int low, high, mid;
    
    low = 0;
    high = n-1;
    
    while(low <= high) {
        mid = (low+high)/2;
        
        if (x[mid]==item)
            return mid;
        else if(x[mid]>item)
            high = mid - 1;
        else
            low = mid + 1;
    }
    
    return -1;
}

 

#include  <stdio.h>

const int N=5;

int binarySearch(int *x, int n, int item); // 函数声明 

int main() {
    int a[N]={2,7,19,45,66};
    int i,index, key;
    
    printf("数组a中的数据:\n");
    for(i=0;i<N;i++)
       printf("%d ",a[i]);
    printf("\n");
    
    printf("输入待查找的数据项: ");
    scanf("%d", &key);
    
    // 调用函数binarySearch()在数组a中查找指定数据项key,并返回查找结果给index
    // 补足代码① 
    // ×××
    index=binarySearch(a,N,key);
    if(index>=0) 
        printf("%d在数组中，下标为%d\n", key, index);
    else
        printf("%d不在数组中\n", key); 
   
   return 0;
}

//函数功能描述：
//使用二分查找算法在从x中查找特定值item，数组x大小为n 
// 如果找到，返回其下标 
// 如果没找到，返回-1 
int binarySearch(int *x, int n, int item) {
    int low, high, mid;
    
    low = 0;
    high = n-1;
    
    while(low <= high) {
        mid = (low+high)/2;
        
        if ( item == *(x+mid) )
            return  mid;
        else if(item < *(x+mid))
            high--;
        else
            low++; 
    }
    
    return -1;
}

 

 实验6：

 

#include <stdio.h>
#include <string.h>
const int N = 5;

void selectSort(char str[][20], int n ); // 函数声明，形参str是二维数组名 
int main() {
    char name[][20] = {"Bob", "Bill", "Joseph", "Taylor", "George"};
    int i;
    
    printf("输出初始名单:\n");
    for(i=0; i<N; i++)
        printf("%s\n", name[i]);
        
    selectSort(name, N);  // 调用选择法对name数组中的字符串排序
    
    printf("按字典序输出名单:\n");
    for(i=0; i<N; i++)
        printf("%s\n", name[i]);
    
    return 0;
} 

// 函数定义
// 函数功能描述：使用选择法对二维数组str中的n个字符串按字典序排序 
void selectSort(char str[][20], int n) {
    char p[20];
    int i,j,k;
    for(i=0;i<n-1;i++)
    {
        k=i;
        for(j=i+1;j<n;j++)
        {
            if(strcmp(str[k],str[j])>0)
                k=j;
        }
        if(k!=i)
        {
            strcpy(p,str[k]);
            strcpy(str[k],str[i]);
            strcpy(str[i],p);
        }
    }
     
}

 

 

实验总结：本次实验中前四个任务要求对指针的使用方法进行了深入的剖析，我在回答每一个思考题的过程中加深了对于指针的理解。我对指针的一些新理解：可以借助右左法则对于夹杂指针的声明进行较为精确的分析；指针与数组夹杂在一起时产生了好多种新的形式来表示数组元素以及访问数组元素，尤其是涉及到二维数组时，我们要明确a[0]的形式实际上表示的是行地址，这与一维数组的规定不同，所以我们在做题的时候要分清是一维数组还是二维数组。

本次实验中踩的坑：对于指向特定数量的一维数组的指针理解还是不够深刻，所以再多选题中漏选了一个；遗忘了第五章数组拓展的一系列字符串函数，这给我在解决任务6时带来了极大的不便。

尚存的疑惑：老师一直强调的是“左右左原则”，但网上的一些信息中却强调的是“右左法则”，所以究竟先看右还是先看左我尚存疑惑。

右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出圆括号。重复这个过程直到整个声明解析完毕。