深入理解c指针（五）

做完作业了

已于 2024-03-08 10:47:00 修改

阅读量1.1k

点赞数 35

分类专栏： c语言文章标签： c语言数据结构开发语言

于 2024-02-28 10:16:43 首次发布

本文链接：https://blog.csdn.net/2301_81723939/article/details/136307083

版权

c语言专栏收录该内容

17 篇文章 3 订阅

订阅专栏

本文详细介绍了C语言中指针与数组的概念，包括数组名的理解、指针访问数组、一维数组传参的本质、冒泡排序示例、二级指针、指针数组以及如何用指针数组模拟二维数组。

摘要由CSDN通过智能技术生成

八、指针与数组

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];

1、数组名的理解

某一数组名就是该数组的首元素地址，即 arr 等价于 &arr[0]。

#include <stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("&arr[0] = %p\n", &arr[0]);
  printf("arr = %p\n", arr);
  return 0;
}

但是有两个例外，除此之外，任何地方使用数组名，数组名都表示首元素的地址。

（1） sizeof（数组名），sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。

#include <stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%d\n", sizeof(arr));
  return 0;
}

（2） &数组名，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址是有区别的）。

#include <stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("&arr[0] = %p\n", &arr[0]);
  printf("arr = %p\n", arr);
  printf("&arr = %p\n", &arr);
  return 0;
}

运行如上代码会发现，输出&arr[0]、arr、&arr 的地址相同，那 arr 和 &arr 有什么区别？

#include <stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("&arr[0] = %p\n", &arr[0]);  //int*
  printf("&arr[0]+1 = %p\n", &arr[0]+1);// +4

  printf("arr = %p\n", arr);  //int*
  printf("arr+1 = %p\n", arr+1); // +4

  printf("&arr = %p\n", &arr);
  printf("&arr+1 = %p\n", &arr+1);  //+40
  return 0;
}

这⾥我们发现 &arr[0] 和 &arr[0] + 1 相差4个字节，arr 和 arr+1相差4个字节，是因为 &arr[0] 和 arr 都是首元素的地址，+1就是跳过⼀个元素。但是 &arr 和 &arr+1 相差40个字节，这就是因为&arr是数组的地址，+1操作是跳过整个数组的。

2、使用指针访问数组

数组的输入与输出，代码如下：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//输入
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
	}
	//输出
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

对上述代码进行分析，数组名 arr 是数组首元素的地址，可以赋值给 p，其实数组名 arr 和 p 在这里是等价的。那既然 arr[ i ] 可以访问数组的元素，那 p[ i ]是否也可以访问数组呢？

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	//输⼊
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//输⼊
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
		//scanf("%d", arr+i);   //也可以这样写
        //scanf("%d", &arr[i]); 
	}
	//输出
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
        //printf("%d ", arr[i]);
        //printf("%d ", *(arr+i));
        //printf("%d",*(p+i));
	}
	return 0;
}

将*(p + i) 换成 p[ i ] 也是能够正常打印的，所以本质上 p[ i ] 是等价于*(p+i)。同理 arr[ i ] 应该等价于*(arr + i)，数组元素的访问在编译器处理的时候，也是转换成首元素的地址+偏移量求出元素的地址，然后解引用来访问的。

3、一维数组传参的本质

我们之前都是在函数外部计算数组的元素个数，那我们可以把函数传给⼀个函数后，函数内部求数组的元素个数吗？

#include <stdio.h>
void test(int arr1[])  //int* arr
{
	int sz2 = sizeof(arr1) / sizeof(arr1[0]);
	printf("sz2 = %d\n", sz2);
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz1 = sizeof(arr) / sizeof(arr[0]);
	printf("sz1 = %d\n", sz1);
	test(arr); //这里的数组名就是数组的首元素地址
	return 0;
}

我们发现在函数内部是没有正确获得数组的元素个数。（数组名是数组⾸元素的地址）；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参本质上传递的是数组首元素的地址。所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。那么在函数内部我们写sizeof(arr) 计算的是⼀个地址的大小（单位字节）而不是数组的大小（单位字节）。正是因为函
数的参数部分是本质是指针，所以在函数内部是没办法求数组元素个数的。（64位系统上，sizeof(int*) 的结果是8）

通过函数打印数组，代码如下：

#include <stdio.h>
void Print(int arr1[])
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);  //arr1[i] == *(arr+i)
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	Print(arr);
	return 0;
}

上面代码等价于
#include <stdio.h>
void Print(int* arr)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(arr+i));  //arr1[i] == *(arr+i)
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	Print(arr);
	return 0;
}

总结：⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

4、冒泡排序

冒泡排序的核心思想：两两相邻的元素进行比较。

基本思路：如果要对n个数进行冒泡排序，那么要进行n-1次趟比较，在第 1 趟比较中要进行n-1次两两比较，在第 j 趟比较中要进行 n - j 次两两比较。从这个基本思路中就会发现，趟数决定了两两比较的次数，这样就很容易将两个for循环联系起来了。

它重复地遍历要排序的列表，逐个比较相邻的元素，并按照大小顺序交换它们。这样，每一次遍历都会将最大（或最小）的元素"冒泡"到列表的末尾，直到整个列表排序完成。

下面是冒泡排序的基本算法步骤：

从列表的第一个元素开始，依次比较相邻的两个元素。
如果前一个元素比后一个元素大（或小，取决于排序方式），则交换它们的位置。
继续向后遍历，比较相邻元素并交换，直到达到列表的末尾。
重复上述步骤，每次遍历都会将当前最大（或最小）的元素冒泡到列表的末尾。
重复执行步骤1-4，直到整个列表排序完成。

利用指针进行冒泡排序代码如下：（以升序为例）

#include<stdio.h>

void bubble_sort(int* p, int n)//参数接收数组元素个数
{
	int i = 0;
	for (i = 0; i < n - 1; i++)  //确定趟数
	{
		int flag = 1;//用来判断是否已经有序，若已经有序则不进行后续比较
		int j = 0;
		for (j = 0; j < n - i - 1; j++)  //每一趟进行比较
		{
			if (*(p + j) > *(p + j + 1))
			{
				flag = 0;//发⽣交换就说明，⽆序
				int tmp = *(p + j);
				*(p + j) = *(p + j + 1);
				*(p + j + 1) = tmp;
			}
		}
		if (flag == 1)//这⼀趟没交换就说明已经有序，后续⽆序排序了
			break;
	}
}
int main()
{
	int arr[20] = { 0 };
	int i=0,n;
	printf("请输入数组长度：");
	scanf("%d", &n);
	printf("请输入 %d 个数字：\n", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &arr[i]);
	}

	bubble_sort(arr, n); //冒泡排序函数
	for (i = 0; i < n;i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

5、练习题-调整奇数偶数顺序

说明：输入一个整数数组，实现一个函数，来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，所有偶数位于数组的后半部分。

方法一：

#include<stdio.h>

void exchange(int arr[], int sz)
{
	int i = 0;
	int right = sz-1;
	for (i = 0; i < sz; )   //对数组内各个数字进行判断
	{
		int num = 0;
		if (arr[i] % 2 != 0 )     //如果是奇数，则无需调换
		{
			i++;
		}
		else               //如果是偶数，则与最后数字调换，再重新判断当前位置调换后的数字
		{
			num = arr[i];
			arr[i] = arr[right];
			arr[right] = num;
			right--;
		}
	}
}

int main()
{
	int arr[20] = { 0 };
	int i = 0, n;
	printf("请输入数组长度：");
	scanf("%d", &n);
	printf("请输入 %d 个数字：\n", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &arr[i]);
	}

	exchange(arr, n); //调换函数 

	for (i = 0; i < n; i++) 
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

方法二：

1. 给定两个下标left和right，left放在数组的起始位置，right放在数组中最后一个元素的位置
2. 循环进行一下操作
 a. 如果left和right表示的区间[left, right]有效，进行b，否则结束循环
 b. left从前往后找，找到一个偶数后停止
 c. right从后往前找，找到一个奇数后停止
 d. 如果left和right都找到了对应的数据，则交换，继续a，

void swap_arr(int arr[], int sz)
{
	int left = 0;
	int right = sz-1;
	int tmp = 0;

	while(left<right)
	{
     // 从前往后，找到一个偶数，找到后停止
		while((left<right)&&(arr[left]%2==1))
		{
			left++;
		}
     
		// 从后往前找，找一个奇数，找到后停止
		while((left<right)&& (arr[right]%2==0))
		{
			right--;
		}
     
     // 如果偶数和奇数都找到，交换这两个数据的位置
     // 然后继续找，直到两个指针相遇
		if(left<right)
		{
			tmp = arr[left];
			arr[left] = arr[right];
			arr[right] = tmp;
		}
	}
}

6、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪⾥？

在这个例子中，swap() 函数接收两个二级指针 p 和 q，并且通过交换它们所指向的地址来实现交换它们所指向的值。在 main() 函数中，我们定义了两个指针 ptr1 和 ptr2 分别指向变量 a 和 b 的地址，并且通过调用 swap() 函数来交换它们的指向。三级、四级、...指针同理。

#include <stdio.h>

void swap(int** p, int** q) 
{
    int* temp = *p;
    *p = *q;
    *q = temp;
}

int main() 
{
    int a = 10, b = 20;
    int* ptr1 = &a, * ptr2 = &b;

    printf("Before Swapping:\n");
    printf("*ptr1 = %d\n", *ptr1);
    printf("*ptr2 = %d\n", *ptr2);

    swap(&ptr1, &ptr2);

    printf("After Swapping:\n");
    printf("*ptr1 = %d\n", *ptr1);
    printf("*ptr2 = %d\n", *ptr2);

    return 0;
}

7、指针数组

指针数组是指针还是数组？
我们类⽐⼀下，整型数组，是存放整型的数组，字符数组是存放字符的数组。
那指针数组呢？是存放指针的数组。

#include <stdio.h>

int main() 
{
    int a = 10, b = 20, c = 30;
    int* ptrArr[3];

    ptrArr[0] = &a;
    ptrArr[1] = &b;
    ptrArr[2] = &c;

    for (int i = 0; i < 3; i++) 
    {
        printf("Value of element %d: %d\n", i, *(ptrArr[i]));
    }

    return 0;
}

8、指针数组模拟二维数组

首先理解第1、2点指针与数组名的关系：

利用指针数组来模拟二维数组的代码如下：

其原理如下，指针数组中的每个指针变量分别指向对应数组的首元素地址：

那么根据其原理对代码进行如下改写，输出结果相同。

#include <stdio.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	//数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
	//数组名就是数组首元素地址
	int* parr[3];
	parr[0] = arr1;
	parr[1] = arr2;
	parr[2] = arr3;

	int i = 0;
	int j = 0;

	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			/*printf("%d ", parr[i][j]);*/
			printf("%d ", *(parr[i] + j));
		}
		printf("\n");
	}
	return 0;
}