深入理解指针2

深入理解指针2

数组名的理解

数组名就是首元素的地址

int arr[]={1,3,2};
printf("%p\n",arr);
printf("%p\n",&arr[0]);

但是有两种情况除外，

1.sizeof(数组名)，sizeof操作符统计的是整个数组的大小，并不是第一个元素的大小, 单位是字节

2.&数组名，它取的整个数组的地址，整个数组的地址其实就是首元素的地址，数组地址+1，跳过的是整个数组

除此之外，你遇到的任何数组名都表示首元素的地址

int arr[]={1,2,34};
printf("%d",sizeof(arr));

//如果是一维数组，打印数组的地址其实就是首元素的地址；
int arr[]={1,3,2};
printf("%p\n",arr);
printf("%p\n",&arr[0]);
printf("%p\n",&arr);//三者打印结果一样printf("%p\n",arr+1);//int类型的指针+1，跳过4个字节
printf("%p\n",&arr[0]+1);//跳过4个字节
printf("%p\n",&arr+1);//并不是跳过4个字节，跳过整个数组

//如果是二维数组，打印出来的地址是第一行的地址，也就是第一个一维数组的地址，而第一个一维数组的地址也就是首元素的地址
int main()
{int stp[2][3] = { {1,2,3},{4,5,6} };printf("%p\n", stp);printf("%p\n",&stp[0]);printf("%p\n",&stp);//三者打印结果一样printf("%p\n", &stp[0] + 1); printf("%p\n", stp+1);printf("%p\n", &stp + 1);return 0;}

指针访问数组

代码示例1

int main()
{int arr[10]={0};int*p=arr;int sz=sizeof(arr)/sizeof(arr[0]);int i=0;for(i=0;i<sz;i++){scanf("%d",p+i);}//循环结束后，p里面存的还是arr，i已经变成10了for(i=0;i<sz;i++){printf("%d ",arr[i]);//printf("%d ",*(p+i));//这样写也是可以的}
return 0;
}

代码示例2

int main()
{int arr[10]={0};int*p=arr;int sz=sizeof(arr)/sizeof(arr[0]);int i=0;for(i=0;i<sz;i++){scanf("%d",p++);//通过指针加减也就是指针偏移的方式，让指针移动}//循环结束后，指针p指向下标为10的元素的地址了，i已经变成10了//p++ 的方式会使 p 的值发生改变,p + i 的方式本身不会改变指针 p 的值，所以这里p要重新赋值p=arr;for(i=0;i<sz;i++){printf("%d ",*(p+i));}
return 0;
}

为了更透彻的理解指针，再举一个例子

//打印结果都是一样的
int main()
{int arr[10]={1,2,3,4,5,6,7,8,9};int*p=arr;int sz=sizeof(arr)/sizeof(arr[0]);int i=0;for(i=0;i<sz;i++){printf("%d ",arr[i]);printf("%d ",*(p+i));printf("%d ",*(arr+i));//因为p=arr，p里面存放的就是arr的地址，所以还可以写成下面的样子printf("%d ",p[i]);printf("%d ",i[arr]);arr[i]=*(arr+i)//arr[i]这样的写法只是一种形式，即使这样写，编译器处理的时候也会转成后面的写法，转换成指针偏移的方式p[i]=*(p+i);//同理//我们知道加法是支持交换律的，所以下面的写法也是对的，不管怎么写，编译器最终都会转成指针偏移arr[i]=*(arr+i)=*(i+arr)=i[arr];}
return 0;
}

p+i到底是不是下标为i的地址呢？我们可以验证一下

int main()
{int arr[10]={1,2,3,4,5,6,7,8,9};int*p=arr;int sz=sizeof(arr)/sizeof(arr[0]);int i=0;for(i=0;i<sz;i++){printf("%p========%p\n",p+i,&arr[i]);}
return 0;
}

一维数组传参的本质

想一下下面的代码为什么会出错？

void print(int arr[])//形参写成数组的形式，一维数组传参，形参的大小可以省略
{int i=0;
int sz=sizeof(arr)/sizeof(arr[0]);//其实是得不到数组元素的个数的,统计的其实是指针变量的大小，也就是地址的大小
for(i=0;i<sz;i++)
{printf("%d ",arr[i]);
}}int main()
{int arr[]={1,2,3,4,5};print(arr);//print函数负责把数组里的元素都打印出来,传给形参的其实是地址return 0;}

因为数组传参的本质其实是把数组的首元素的地址传给形参，所以形参接收到的其实是地址，也就是指针，所以统计 sizeof (arr)其实是统计的地址大小，如果平台是32位的，那么它的大小就是4个字节，而sizeof(arr[0])的大小是4 ，所以sz=4/4=1，所以打印在屏幕上只打印了1一个数字

//那既然函数内部不能统计数组元素的个数，只能在main函数内部统计数组元素个数我们就在main函数内部计算，然后作为实参传给形参。
//因为实参传给形参的数组名其实是首元素地址，那么用sizeof统计的其实是指针变量的大小

void print(int*arr,int sz)//形参写成指针的形式
{int i=0;for(i=0;i<sz;i++)
{printf("%d ",arr[i]);
}}int main()
{int arr[]={1,2,3,4,5};int sz=sizeof(arr)/sizeof(arr[0]);print(arr,sz);//print函数负责把数组里的元素都打印出来,传给形参的其实是地址return 0;}

//我们用下面的代码验证下就知道了，数组名其实就是地址

void print(int arr[],int sz)
{
printf("%d\n",sizeof(arr));
}void print(int*arr,int sz)
{
printf("%d\n",sizeof(arr));
}int main()
{int arr[]={1,2,3,4,5};int sz=sizeof(arr)/sizeof(arr[0]);print1(arr,sz);print2(arr,sz);
return 0;
}

总结：

数组传参，无论形参是写成数组的形式还是指针的形式，本质上都是一样的，只是形式不同而已。

编译器最终都会转成指针的方式处理。

冒泡排序

方法1

void double_paixu(int * arr,int sz)
{int i = 0;//排序第一步根据元素个数确定排序的轮数for (i=0;i<sz-1;i++)//i的最大取值为3{//排序第二步，在每一轮排序中确定要比较的元素对数，随着轮数的增加，要排序的元素对数依次递减，所以比较的次数//根i有关系，因为变量i代表的是比较的轮数int j = 0;//j表示元素的下标,又表示元素比较的对数//内层for循环用于比较元素大小和交换，如果是降序，发现前一个元素小于后一个元素，就交换for (j = 0; j <sz-1-i ;j++)//{if (arr[j] < arr[j + 1])//一共有5个元素，但是j最大的取值为3，当j=3时，arr[3]和arr[4]进行比较//如果j=4，那就数组越界了，因为arr[4]和arr[5]进行比较，但是数组只有5个元素{int d = 0;d = arr[j];arr[j] = arr[j + 1];arr[j + 1] = d;}}}
}
int main()
{int arr[] = { 12,21,2,45,1};int sz = sizeof(arr) / sizeof(arr[0]);double_paixu(arr,sz);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}

//优化版：如果要排序的序列本身是有序的，那么第一轮比较后发现没有交换，就证明是有序的，就不用进入下一轮的比较了

void double_arr(int* arr, int sz)
{int i = 0;for (i = 0; i < sz - 1; i++)//i的最大值为2{int j = 0;int flag = 1;//假设是有序的//如果是降序的话，就是找出最小值，如果a<b就交换for (j = 0; j < sz - 1 - i; j++)//j的最大值为2a{if (arr[j] > arr[j + 1]){int temp = 0;temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;//如果进来了，就说明是无序的flag = 0;}}//如果第一轮循环结束后，flag还是等于1，说明是有序的，就不用进入下一轮了if (flag == 1){break;}}//跳出循环来到这
}
void print(int* arr, int sz)
{int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}
int main()
{int arr[] = { 1,2,3,4};int sz = sizeof(arr) / sizeof(arr[0]);double_arr(arr, sz);print(arr, sz);return;
}

方法2：用qsort函数的方法

二级指针

指针变量也是变量，既然是变量就要像内存申请一块空间，既然有自己的内存空间，那肯定就有地址，那么指针变量的地址存放在哪里呢？这就是二级指针

1.二级指针变量创建

int a=10;
int*p=&a;//p存放的是a的地址，*本身p是一个指针变量，int表示p指向一个整型数据，int*是变量p的类型，整型指针int* *pa=&p;//pa存放的是一级指针变量p的地址，*表示pa是一个指针变量，int*表示pa指向一个一级指针地址，int**是变量pa的类型，是一个二级指针int** *paa=&pa;//paa存放的是二级指针变量pa的地址，*表示paa是一个指针变量，int**表示paa指向一个二级指针地址，int***是变量paa的类型，是一个三级指针

2.二级指针解引用

int main()
{int a = 10;int* p = &a;int* * pa = &p;int** * paa = &pa;printf("%d\n",*p);//p解引用后，打印a的值printf("%d\n",*pa)//pa解引用后，打印一级指针变量p的地址printf("%d\n",*paa);//paa解引用后，打印二级指针变量pa的地址//如果想打印a的值printf("%d\n",*p);//对一级指针变量解引用printf("%d\n",*(*pa));//对二级指针变量解引用printf("%d\n",*(*(*paa)))//对三级指针变量解引用printf("%d\n", **pa);//这样写也是对的，不带括号也是可以的printf("%d\n", ***paa);//对三级指针变量接return 0;
}

总结：

1.二级指针变量没有什么牛逼的，和一级指针变量一样，都是指针变量，用来存放地址

2.二级指针变量用来存放一级指针变量的地址，同理，三级指针变量用来存放二级指针变量的地址

指针数组

数组有很多种类型，我们之前已经学过的有字符数组，整型数组，字符数组是用来存放字符串的，整型数组用来存放整型。

今天我们学习的指针数组，就是用来存放指针的，即地址。指针数组里的每一个元素都是指针。当然指针数组也有很多种类型，有int*，char*, long*, double*等等

//定义一个指针数组，然后把指针数组里每一个指针指向的元素打印出来

int main()
{int a=10;int b=20;int c=40;int*arr[]={&a,&b,&c};//arr[]表示数组，int*表示数组里的每一个元素都是int*类型的指针，即都是指向int类型的数据int i=0;for(i=0;i<3;i++){printf("%d ",*(arr[i]));}return 0;
}

//上面的代码没什么问题，但是我们很少这样去用,一般都指针数组模拟二维数组

int main()
{int arr1[]={1,2,3,4};int arr2[]={5,6,7,8};int arr3[]={9,10,11,12};int*p[]={arr1,arr2,arr3};int i=0;//外层循环控制指针数组arr1  arr2  arr3里的每一个元素for(i=0;i<3;i++){int j=0;//内层循环控制指针数组里的每一个指针指向的整型for(j=0;j<4;j++){printf("%d ",*(p[i]+j));//p[i]是数组p里下标为i的元素，当i=0时，拿到的是arr1，也就是数组名，然后再加j,就是让指针指向arr1数组里下标为j的地址，然后解引用，就拿到arr1数组里的元素// printf("%d ",p[i][j]);// printf("%d ",*(*(p+i)+j));//这几种写法都可以}printf("\n");}return 0;
}