指针练习

指针练习

一：a的相关信息

#include <stdio.h>
int main(void)
{
    int a[4][2]={ {2,4},{6,8},{1,3},{5,7} }; 
printf("a=%p , a+1=%p\n",a,a+1);//两个int 
printf("a[0]=%p , a[0]+1=%p\n",a[0],a[0]+1);//一个int 
printf("*a=%p , *a+1=%p\n",*a,*a+1);// a[0]和 *a 完全相同 
printf("a[0][0]=%d\n",a[0][0]);
printf("*a[0]=%d\n",*a[0]);
printf("**a=%d\n",**a);
printf("a[2][1]=%d\n",a[2][1]);
printf("*(*(a+2)+1)=%d\n",*(*(a+2)+1)); // *(*(a+2)+1)相当于a[2][1]

return 0;

}

​

​

// %p是指针的输出装换符 

输出结果：

a=000000000062FE00 , a+1=000000000062FE08
a[0]=000000000062FE00 , a[0]+1=000000000062FE04
*a=000000000062FE00 , *a+1=000000000062FE04
a[0][0]=2
*a[0]=2
**a=2
a[2][1]=3
*(*(a+2)+1)=3

1. 二维数组a的地址和一维数组a[0]的地址相同，都是各自首元素的地址

2. a[0]指向一个4字节的数据对象，a[0]加1，其值加4(16进制中)。数组名是一个内含2个int类型的数组地址，所以a指向一个8字节的数据对象，因此a加1，它所指向的地址加8字节(16进制中)。

3. a[0]和*a完全相同

4. 数组地址，数组内容和指针之间的关系：

 

二：编写一个函数，返回存储在double类型数组中最大值和最小值的差值

#include<stdio.h>
double max_min(double arr[], int n);
int main(void)
{
    double a[5] = { 3.6,3.8,4.6,2.3,6.3 };
    printf("the diff is %1.1f\n", max_min(a, 5));
    return 0;
}
​
double  max_min(double arr[], int n)
{
    double max;
    double min;
    min = max =arr[0];
    int i;
    for ( i = 1; i < n; i++)
    {
        if(max<arr[i]) max=arr[i];
        if(min>arr[i]) min=arr[i];
    }
    return max-min;
}

 

三：把double的数组倒序排列

#include<stdio.h>
double r_sort(double arr[], int n);
int main(void)
{
    double a[5] = { 3.6,3.8,4.6,2.3,6.3 };
    int i;
    for(i=0;i<5;i++) printf("%g ",a[i]);// '%g'是根据值的不同，自动选择 %f 或者 %e(浮点数）。%e格式用于指数小于-4或者大于或等于精度时  
    printf("\n");
    r_sort(a,5);
    for(i=0;i<5;i++) printf("%g ",a[i]);
    return 0;
}
​
double  r_sort(double arr[], int n)
{
    double temp;
    int i,j;
    for(i=0;i<n-1;i++){
        for(j=0;j<n-1-i;j++){
            if(arr[j]<arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}

1. 用的比较排序法，判断相邻元素的大小关系，并对需要排序的两个数组交换位置。内层循环一次能保证一个元素调整到合适位置，在n-1次外层循环中保证所有元素都到正确位置。

2. 循环判断条件设置为 j<n-1 也可以，只是会多执行一些无效的循环判断。（具体原因是：每次循环可以保证1个元素到达正确位置 ，该位置后续排序过程可以忽略，以提高效率。

3.