重头开始嵌入式第十五天（指针操作二维数组，指针的数组，指针的指针，函数指针，回调函数）

目录

指针操作二维数组

指针操作二维字符型数组

指针操作二维字符型数组和普通二维数组的区别

指针的数组

指针的指针

函数指针

main函数的参数

---

指针操作二维数组

在 C 语言中，通过指针操作二维数组常见的方式如下：
 
假设我们有一个二维数组  int arr[3][4]  。
 
我们可以把二维数组看作是由多个一维数组组成的。
 
方式一：

int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };

// 指向二维数组首元素的指针
int (*p)[4] = arr;

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        printf("%d ", (*(p + i))[j]);
    }
    printf("\n");
}

方式二：

int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };

// 指向数组元素的指针
int *ptr = &arr[0][0];

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        printf("%d ", *(ptr + i * 4 + j));
    }
    printf("\n");
}

这两种方式都可以通过指针来访问和操作二维数组中的元素。

在 C 语言中，通过指针访问二维数组元素一般有以下步骤：

假设我们有一个二维数组  int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }; 

方式一：使用指向数组的指针

1. 首先，定义一个指向具有特定列数的一维数组的指针，例如  int (*p)[4] = arr;  这里的  p  是一个指向包含 4 个整数的一维数组的指针。

2. 要访问特定行特定列的元素，通过移动指针  p  到指定的行。比如要访问第  i  行（从 0 开始计数），使用  p + i  。

3. 然后，再通过下标访问列元素，例如  (*(p + i))[j]  ，其中  j  是列的索引（从 0 开始计数）。

方式二：使用指向元素的指针

1. 定义一个指向数组元素的指针，例如  int *ptr = &arr[0][0];  这里  ptr  指向二维数组的第一个元素。

2. 因为二维数组在内存中是按行顺序存储的，所以要访问第  i  行第  j  列的元素，可以通过计算偏移量来实现。偏移量的计算方式是  i * 列数 + j  ，在这个例子中就是  i * 4 + j  。

3. 然后通过  *(ptr + i * 4 + j)  来访问特定的元素。

总之，使用指针访问二维数组元素的关键在于理解二维数组在内存中的存储方式以及如何通过指针的移动和计算偏移量来准确地定位和访问所需的元素。

指针操作二维字符型数组

在 C 语言中，使用指针操作二维字符型数组与操作其他类型的二维数组类似。
 
假设我们有一个二维字符型数组  char arr[3][10] = { "Hello", "World", "Goodbye" }; 
 
方式一：使用指向一维数组的指针

char (*p)[10] = arr;

for (int i = 0; i < 3; i++) {
    printf("%s\n", *(p + i));
}

方式二：使用指向单个字符的指针

char *ptr = &arr[0][0];

for (int i = 0; i < 3; i++) {
    printf("%s\n", ptr + i * 10);
}

 
在方式一中， p  是一个指向包含 10 个字符的一维数组的指针。通过  *(p + i)  可以获取到每一行的起始地址，并以字符串形式输出。
 
在方式二中， ptr  指向二维数组的第一个字符。通过计算偏移量  ptr + i * 10  来获取每一行的起始地址，并以字符串形式输出。

指针操作二维字符型数组和普通二维数组的区别

二维字符型数组的指针和普通数组指针（假设这里指的是指向其他数据类型的二维数组的指针）在本质上的操作方式是相似的，但由于所指向的数据类型不同，可能在使用和理解上存在一些细微的区别：

1. 数据类型：最明显的区别是它们所指向的数据类型不同。二维字符型数组的指针指向的是字符数据，而普通数组指针指向的是其他特定的数据类型，如整数、浮点数等。

2. 字符串处理：对于二维字符型数组的指针，由于字符数据常常用于表示字符串，所以在处理时可能会更多地涉及到字符串操作，如字符串的输出、比较、拼接等。而普通数组指针在处理时更多是基于其特定的数据类型进行数值运算或逻辑判断。

3. 内存占用：不同的数据类型在内存中占用的字节数不同。字符型通常占用 1 个字节，而其他数据类型如整数、浮点数等占用的字节数则根据其具体类型而定。这会影响指针移动和计算偏移量时的步长。

4. 应用场景：二维字符型数组常用于存储和处理文本相关的数据，而普通数组指针则根据其所指向的数据类型应用于各种不同的数值计算或数据存储场景。

总的来说，尽管操作方式相似，但由于数据类型的差异，它们在具体的应用和处理细节上会有所不同，需要根据具体的需求和场景来正确使用。

指针的数组

“指针的数组”是指一个数组，其中的元素都是指针。

例如，如果要创建一个整数指针的数组，可以这样写：

int *arr[5]; // 定义了一个包含 5 个整数指针的数组

在这个数组中，每个元素（如  arr[0]  、  arr[1]  等）都可以用来存储一个指向整数的指针。

使用指针的数组可以方便地管理多个指向相关数据的指针，在很多情况下能够提高程序的灵活性和效率。例如，当需要动态分配内存来存储多个相关的整数，并通过数组来统一管理这些内存地址时，就可以使用整数指针的数组。

字符型

char *p[]={"hello","chain","world"};

使用如下

void printfArray(char **p,int n)
 {
      for(int i=0;i<n;i++)
          printf("%s\n",p[i]);
 }

指针的指针

指针的指针，又称为二级指针，是指向指针的指针。
 
例如， int **ptr;  这里的  ptr  就是一个二级指针，它可以用来指向一个一级指针。
 
在内存中，二级指针存储的是一级指针的地址。通过二级指针，可以更灵活地操作和管理内存中的指针数据。
 
使用二级指针的常见场景包括动态分配二维数组、处理指针数组等。
 
比如，动态分配一个二维整数数组可以这样实现：
 
 

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3, cols = 4;
    int **arr;

    arr = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        arr[i] = (int *)malloc(cols * sizeof(int));
    }

    // 对动态分配的二维数组进行操作

    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}
 

 
在上述示例中，通过二级指针  arr  实现了二维数组的动态分配和管理。

函数指针

函数指针是指向函数的指针变量。

函数指针的声明形式一般为： 返回值类型 (*指针变量名)(参数列表); 

例如，假设有一个函数  int add(int a, int b)  ，那么对应的函数指针声明可以是  int (*ptr)(int, int);  。

函数指针的主要用途包括：

1. 实现函数回调：将函数指针作为参数传递给其他函数，使得被调用的函数可以在内部根据不同的情况调用不同的函数，增加了程序的灵活性和可扩展性。

2. 动态选择执行的函数：根据不同的条件或用户输入，通过函数指针选择要执行的具体函数。

以下是一个简单的函数指针示例：

#include <stdio.h>



// 定义两个函数

int add(int a, int b) {

    return a + b;

}



int subtract(int a, int b) {

    return a - b;

}



// 函数接受函数指针作为参数

void operate(int (*func)(int, int), int num1, int num2) {

    int result = func(num1, num2);

    printf("结果: %d\n", result);

}



int main() {

    int num1 = 5, num2 = 3;



    // 使用函数指针调用 add 函数

    operate(add, num1, num2);



    // 使用函数指针调用 subtract 函数

    operate(subtract, num1, num2);



    return 0;

}

在上述示例中， operate  函数接受一个函数指针作为参数，根据传递的不同函数指针来执行相应的操作。

main函数的参数

在 C 语言中， main  函数可以带有参数，其常见的形式为：

int main(int argc, char *argv[])

其中：
 
-  argc  是一个整数，代表命令行参数的个数（包括程序名本身）。
-  argv  是一个字符指针数组，其中每个元素指向一个命令行参数的字符串。
 
例如，如果在命令行中运行程序  ./myProgram arg1 arg2  ，那么：
 
-  argc  的值为 3，分别是  "./myProgram"  、  "arg1"  、  "arg2"  。
-  argv[0]  指向  "./myProgram"  ， argv[1]  指向  "arg1"  ， argv[2]  指向  "arg2"  。
 
通过对  argc  和  argv  的处理，可以使程序根据不同的命令行输入执行不同的操作，增强了程序的灵活性和交互性。