概述
本文详细介绍了数组与指针的基本概念及其关系，并深入讲解了数组指针的声明、初始化和操作方法。文中还探讨了数组指针在函数参数传递、动态内存分配以及高级编程中的应用，并通过示例代码展示了数组指针的学习和使用技巧。数组指针学习涵盖了从基础操作到高级应用的全面内容。
数组与指针的基础概念 数组的基本定义在C语言中，数组是一种基本的数据结构，用于存储一系列类型相同的数据元素。数组的每个元素拥有相同的类型，并且在内存中是连续存储的。数组的定义通常包括数组的类型、数组的名字和数组的大小（即数组元素的数量）。
语法
type name[size];示例
int numbers[5]; // 定义一个整型数组，包含5个元素指针是一种变量，用于存储内存地址。在C语言中，通过指针可以访问或修改存储在该地址的数据。指针的类型决定了它能存储的地址类型，例如，一个int类型的指针只能存储整型变量的地址。
语法
type *pointer;示例
int *p; // 定义一个指向整型数据的指针p数组名本身是一个指向该数组第一个元素的指针常量。这意味着，数组名可以被视为一个常量指针，指向数组的第一个元素。因此，可以使用指针操作来访问和修改数组中的元素。
示例
int numbers[5] = {1, 2, 3, 4, 5};
int *p = numbers; // 数组名numbers就是一个指向第一个元素的指针
printf("%d\n", *p); // 输出数组的第一个元素 1
p++;
printf("%d\n", *p); // 输出数组的第二个元素 2数组指针是指向数组的指针变量。它能够存储数组的地址，并且可以通过数组指针来访问或修改数组中的元素。
语法
type (*pointer)[size];示例
int numbers[5] = {1, 2, 3, 4, 5};
int (*p)[5] = &numbers; // 定义一个指向数组的指针p
printf("%d\n", (*p)[0]); // 输出数组的第一个元素 1通过数组指针，可以直接使用(*pointer)[index]或pointer[index]来访问指定的数组元素。前者更加明确地表明了指针的解引用操作，后者则更为简洁。
示例
int numbers[5] = {1, 2, 3, 4, 5};
int (*p)[5] = &numbers;
printf("%d\n", (*p)[0]); // 输出第一个元素 1
printf("%d\n", p[0][0]); // 输出第一个元素 1数组指针常常用于传递数组作为函数参数，或者在动态内存分配中使用。
传递数组作为函数参数
通过使用数组指针，可以在函数中处理任意大小的数组，而不需要在函数声明中指定数组的大小。
示例
void printArray(int (*arr)[5], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", (*arr)[i]);
}
printf("\n");
}
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
int (*p)[5] = &numbers;
printArray(p, 5); // 输出 1 2 3 4 5
return 0;
}动态分配内存
在C语言中，可以使用malloc函数动态分配内存来创建数组，并使用数组指针来访问这些动态分配的内存区域。
示例
int main() {
int size = 5;
int *array = (int*) malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
array[i] = i;
}
printf("%d\n", array[0]); // 输出 0
free(array);
return 0;
}使用数组指针作为函数参数可以传递任意大小的数组，并且能够直接修改传递进来的数组中的值。
示例
void modifyArray(int (*arr)[5], int size) {
for (int i = 0; i < size; i++) {
(*arr)[i] *= 2;
}
}
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
int (*p)[5] = &numbers;
modifyArray(p, 5);
for (int i = 0; i < 5; i++) {
printf("%d ", numbers[i]);
}
printf("\n"); // 输出 2 4 6 8 10
return 0;
}动态分配内存时，使用数组指针可以更方便地访问动态分配的内存区域，并且能够直接修改分配的内存区域中的值。
示例
int main() {
int size = 5;
int (*array)[size] = (int*) malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
(*array)[i] = i;
}
printf("%d\n", (*array)[0]); // 输出 0
free(array);
return 0;
}在数据结构中，例如动态数组（如vector），数组指针常常用于存储和操作动态分配的数据结构。
示例
#include <stdlib.h>
#define SIZE 10
typedef struct {
int *data;
int capacity;
int size;
} DynamicArray;
void initDynamicArray(DynamicArray *array) {
array->data = (int*) malloc(SIZE * sizeof(int));
array->capacity = SIZE;
array->size = 0;
}
void appendDynamicArray(DynamicArray *array, int value) {
if (array->size == array->capacity) {
array->capacity *= 2;
array->data = (int*) realloc(array->data, array->capacity * sizeof(int));
}
array->data[array->size++] = value;
}
void printDynamicArray(DynamicArray *array) {
for (int i = 0; i < array->size; i++) {
printf("%d ", array->data[i]);
}
printf("\n");
}
int main() {
DynamicArray da;
initDynamicArray(&da);
appendDynamicArray(&da, 1);
appendDynamicArray(&da, 2);
appendDynamicArray(&da, 3);
printDynamicArray(&da); // 输出 1 2 3
free(da.data);
return 0;
}数组指针指向整个数组，其类型表明了数组的元素类型和大小。普通指针指向单个元素，其类型只表明了元素的类型。
示例
int numbers[5] = {1, 2, 3, 4, 5};
int *p = numbers; // 指向第一个元素
int (*pArr)[5] = &numbers; // 指向整个数组数组指针的生命周期和数组本身相同。如果数组是静态数组，或者是在堆上动态分配的，那么数组指针的生命周期也相应地长。如果数组是在栈上分配的局部变量，则数组指针的有效范围是该局部变量的作用范围。
示例
void example() {
int numbers[5] = {1, 2, 3, 4, 5};
int (*p)[5] = &numbers;
// 使用 p 访问 numbers
}
int main() {
example();
// 此处无法使用 p，因为已经超出作用范围
return 0;
}错误使用数组指针可能导致访问越界、内存泄漏等问题。例如，错误地使用指针进行数组元素的访问，或者忘记释放动态分配的内存。
示例
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
int *p = numbers; // 指向第一个元素
p[5] = 6; // 越界访问，可能会导致程序崩溃
free(p); // p 不是动态分配的内存，使用 free 会导致错误
return 0;
}多维数组可以理解为数组中的每个元素也是一个数组。使用数组指针可以方便地访问和操作多维数组。
示例
int main() {
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int (*p)[3] = matrix; // 指向第一维数组
printf("%d\n", (*p)[0]); // 输出 1
p++;
printf("%d\n", (*p)[0]); // 输出 4
return 0;
}数组指针的解引用操作可以理解为先解引用指针得到数组的第一个元素，再通过下标访问具体的元素。这种操作方式在处理多维数组时尤为重要。
示例
int main() {
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int (*p)[3] = matrix; // 指向第一维数组
printf("%d\n", (*p)[0][0]); // 输出 1
return 0;
}数组指针在高级编程中，如函数指针、回调函数、内存管理等场景中都有广泛的应用。
示例
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
int (*p)[5] = &numbers;
void (*func)(int *) = &printArray;
func((int*)p, 5); // 通过函数指针调用 printArray 函数
return 0;
}void sortArrayAscending(int (*arr)[5], int size) {
int i = 0;
int j = size - 1;
while (i < j) {
int temp = (*arr)[i];
(*arr)[i] = (*arr)[j];
(*arr)[j] = temp;
i++;
j--;
}
}
int main() {
int numbers[5] = {5, 4, 3, 2, 1};
int (*p)[5] = &numbers;
sortArrayAscending(p, 5);
for (int i = 0; i < 5; i++) {
printf("%d ", (*p)[i]);
}
printf("\n"); // 输出 1 2 3 4 5
return 0;
}- 实现一个函数，该函数接收一个指向数组的指针和数组的大小，并将数组元素反转。
- 实现一个函数，该函数接收一个指向多维数组的指针，并输出该多维数组。
- 实现一个函数，该函数接收一个指向动态分配内存的数组指针，并释放该内存。
示例
void reverseArray(int (*arr)[5], int size) {
int i = 0;
int j = size - 1;
while (i < j) {
int temp = (*arr)[i];
(*arr)[i] = (*arr)[j];
(*arr)[j] = temp;
i++;
j--;
}
}
void printMatrix(int (*matrix)[3], int rows, int cols) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
}
void freeArray(int **arr) {
free(*arr);
*arr = NULL;
}案例一：实现一个简单的二维数组排序
实现一个函数，该函数接收一个指向二维数组的指针，并对该二维数组进行排序。排序规则为：先根据行的第一个元素排序，然后在每一行内根据元素的大小进行排序。
示例
void sortMatrix(int (*matrix)[3], int rows, int cols) {
// 先根据行的第一个元素进行排序
for (int i = 0; i < rows - 1; i++) {
for (int j = i + 1; j < rows; j++) {
if (matrix[i][0] > matrix[j][0]) {
for (int k = 0; k < cols; k++) {
int temp = matrix[i][k];
matrix[i][k] = matrix[j][k];
matrix[j][k] = temp;
}
}
}
}
// 每一行内部排序
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols - 1; j++) {
for (int k = j + 1; k < cols; k++) {
if (matrix[i][j] > matrix[i][k]) {
int temp = matrix[i][j];
matrix[i][j] = matrix[i][k];
matrix[i][k] = temp;
}
}
}
}
}
int main() {
int matrix[3][3] = {
{3, 2, 1},
{6, 5, 4},
{9, 8, 7}
};
sortMatrix(matrix, 3, 3);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}案例二：实现一个简单的内存池
实现一个内存池，该内存池用于动态分配和回收固定大小的内存块。内存池需要支持分配内存块、释放内存块和清空内存池的操作。
示例
#define BLOCK_SIZE 10
typedef struct {
int *blocks;
int capacity;
int count;
} MemoryPool;
void initMemoryPool(MemoryPool *pool, int capacity) {
pool->blocks = (int*) malloc(capacity * BLOCK_SIZE * sizeof(int));
pool->capacity = capacity;
pool->count = 0;
}
int *allocateBlock(MemoryPool *pool) {
if (pool->count < pool->capacity) {
int *block = &pool->blocks[pool->count * BLOCK_SIZE];
pool->count++;
return block;
}
return NULL;
}
void freeBlock(MemoryPool *pool, int *block) {
int index = (block - pool->blocks) / BLOCK_SIZE;
if (index >= 0 && index < pool->count) {
pool->count--;
for (int i = index * BLOCK_SIZE; i < (index + 1) * BLOCK_SIZE; i++) {
pool->blocks[i] = 0;
}
}
}
void clearMemoryPool(MemoryPool *pool) {
pool->count = 0;
}
int main() {
MemoryPool pool;
initMemoryPool(&pool, 5);
int *block1 = allocateBlock(&pool);
*block1 = 10;
int *block2 = allocateBlock(&pool);
*block2 = 20;
freeBlock(&pool, block1);
block1 = allocateBlock(&pool);
*block1 = 30;
clearMemoryPool(&pool);
free(pool.blocks);
return 0;
}點擊查看更多內容
為 TA 點贊
評論
評論
共同學習，寫下你的評論
評論加載中...
作者其他優質文章
正在加載中
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦