目录

数组名的理解

使用指针访问数组

一维数组传参的本质

冒泡排序

二级指针

指针数组

指针数组模拟二维数组

---

数组名的理解

数组名是数组首元素的地址

例外：

sizeof(数组名),sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("arr      =%p\n", arr);
	printf("arr+1    =%p\n", arr + 1);
	printf("&arr[0]  =%p\n", &arr[0]);
	printf("&arr[0]+1=%p\n", &arr[0]+1);
	printf("&arr     =%p\n", &arr);
	printf("&arr+1   =%p\n", &arr+1);
	return 0;
}

运行结果：

使用指针访问数组

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

[ ]下标引用操作符  arr[ i ]=i [arr]

数组就是数组，是一块连续的空间（数组的大小和数组元素个数和元素类型都有关系）

指针（变量）就是指针（变量），是一个变量（4/8个字节）

一维数组传参的本质

先看一段代码：

//数组传参的时候，形参是可以写成数组形式的，但本质还是指针变量
void Print(int arr[10])//int* arr
{
	int sz = sizeof(arr) / sizeof(arr[0]);//4/4=1  得不到元素个数
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	Print(arr);//arr 数组名就是数组首元素地址
	return 0;
}

运行结果：

数组传参的本质是传递了数组首元素的地址，所以形参访问的数组和实参的数组是同一个数组；形参的数组是不会再单独创建数组空间的，所以形参的数组是可以省略掉数组的大小的

下面这段代码是真正传递整个数组的：

void Print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Print(arr,sz);//arr 数组名就是数组首元素地址
	return 0;
}

一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式

冒泡排序

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

void bubble_sort(int arr[], int sz)
{
	int i = 0, j = 0;
	for (i = 0; i < sz; i++)//趟数
	{
		for (j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
void Print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	Print_arr(arr, sz);
	return 0;
}

在这段代码中，如果针对于接近排好序的序列，是比较浪费时间的，下面对这段代码进行优化：

void bubble_sort(int arr[], int sz)
{
	int i = 0, j = 0, flag = 1;
	for (i = 0; i < sz; i++)//趟数
	{
		for (j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])//相邻交换
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			}
		}
		if (flag == 1)//第i趟是有序的，直接跳出
		{
			break;
		}
	}
}
void Print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	Print_arr(arr, sz);
	return 0;
}

二级指针

int main()
{
	int a = 10;
	int* p = &a;//p是一级指针
	int** pp = &p;//pp是二级指针,类型是int**
	printf("%p\n", p);
	printf("%p\n", pp);
	return 0;
}

int**pp=&p;

int*（前面的）说明pp指向的p的类型是int*类型；*（后面的）说明pp是指针变量

int main()
{
	int a = 10;
	int* p = &a;
	int** pp = &p;
	printf("%p\n", *pp);//p
	printf("%p\n", &a);
	printf("%d\n", **pp);//a=10
	return 0;
}

运行结果：

指针数组

存放指针的数组，指针数组的每个元素都是用来存放地址（指针）的

指针数组模拟二维数组

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int* arr[] = { arr1,arr2,arr3 };//指针数组
	int i = 0, j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}