1、指针数组

指针数组的定义：type* pArray[n];    例如，  int* pa[3]

• 指针数组中每个元素为一个指针
• type*为数组中每个元素的类型
• pArray为数组名
• n为数组大小

例如，

#include <stdio.h>
#include <string.h>
int lookup_keyword(const char* key, const char* table[], const int size)
{
    int ret = -1;
    int i = 0;
    for(i=0; i<size; i++)
    {
        if( strcmp(key, table[i]) == 0 )
        {
            ret = i;
            break;
        }
    }
    return ret;
}
#define DIM(a) (sizeof(a)/sizeof(*a))
int main()
{
    const char* keyword[] = {
            "do",
            "for",
            "if",
            "register",
            "return",
            "switch",
            "while",
            "case",
            "static"
    };
    printf("%d\n", lookup_keyword("return", keyword, DIM(keyword)));
    printf("%d\n", lookup_keyword("main", keyword, DIM(keyword)));
}

2、数组指针

数组指针用于指向一个数组。

• 数组名是数组首元素的起始地址，但并不是数组的起始地址 
• 通过将取地址符&作用于数组名可以得到数组的起始地址，例如，&array
• 可通过数组类型定义数组指针: ArrayType* pointer; 例如， array int* pc
• 也可以直接定义：type (*pointer)[n];例如，int（*pc）[5]
• pointer为数组指针变量名
• type为指向的数组的类型
• n为指向的数组的大小

#include <stdio.h>
typedef int(AINT5)[5];
typedef float(AFLOAT10)[10];
typedef char(ACHAR9)[9];
int main()
{
    AINT5 a1;
    float fArray[10];
    AFLOAT10* pf = &fArray;
    ACHAR9 cArray;
    char(*pc)[9] = &cArray;
    char(*pcw)[4] = cArray;
    int i = 0;
    printf("%d, %d\n", sizeof(AINT5), sizeof(a1));
    for(i=0; i<10; i++)
    {
        (*pf)[i] = i;
    }
    for(i=0; i<10; i++)
    {
        printf("%f\n", fArray[i]);
    }
    printf("%0X, %0X, %0X\n", &cArray, pc+1, pcw+1);
}

3、指针数组和数组指针的区别

1）指针数组

指针数组：指针数组可以说成是 ”指针的数组”，首先这个变量是一个数组。

其次，”指针”修饰这个数组，也就是说这个数组的所有元素都是指针类型。

在 32 位系统中，指针占四个字节。

2）数组指针

数组指针：数组指针可以说成是”数组的指针”，首先这个变量是一个指针。

其次，”数组”修饰这个指针，也就是说这个指针存放着一个数组的首地址，或者说这个指针指向一个数组的首地址。

所以指针数组和数组指针的区别，因为二者根本就是两种类型的变量。

4、指针数组的使用

指针数组在存储字符串时非常常用，因为每个字符串本质上是一个字符数组，指针可以指向字符串的首地址。

1）指针数组用于存储指向变量的指针

#include <stdio.h>

int main() {
    int a = 10, b = 20, c = 30;
    int *arr[3];  // 定义一个存储指向 int 类型数据的指针数组

    // 将变量的地址存储在指针数组中
    arr[0] = &a;
    arr[1] = &b;
    arr[2] = &c;

    // 通过指针数组访问变量的值
    printf("a = %d, b = %d, c = %d\n", *arr[0], *arr[1], *arr[2]);

    return 0;
}

2）指针数组用于存储字符串

#include <stdio.h>

int main() {
    // 定义一个指向字符串的指针数组
    char *arr[] = {"Hello", "World", "C programming"};

    // 输出指针数组中的字符串
    for (int i = 0; i < 3; i++) {
        printf("%s\n", arr[i]);
    }

    return 0;
}

5、指针数组和二维数组的区别

指针数组与二维数组是不同的，尽管它们都可以用于存储多个字符串或数组。指针数组中的每个元素都是一个指针，而二维数组中的每个元素都是一个数组元素。

#include <stdio.h>

int main() {
    // 定义一个二维字符数组
    char arr1[3][10] = {"Hello", "World", "C"};

    // 定义一个指向字符串的指针数组
    char *arr2[3] = {"Hello", "World", "C"};

    printf("二维数组访问：%s\n", arr1[0]);
    printf("指针数组访问：%s\n", arr2[0]);

    return 0;
}

6、指针数组作为函数参数

指针数组可以作为函数的参数，用于传递多个指针（例如，多个字符串的首地址）。

#include <stdio.h>

// 函数接收指针数组并输出每个字符串
void printStrings(char *arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%s\n", arr[i]);
    }
}

int main() {
    char *arr[] = {"Hello", "World", "C programming"};

    printStrings(arr, 3);  // 调用函数并传递指针数组

    return 0;
}

7、指针数组与动态内存分配

指针数组可以与动态内存分配结合使用，以便在运行时灵活地管理内存。使用 malloc() 可以动态分配每个指针指向的内存。

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

int main() {
    char *arr[3];  // 指针数组，存储指向字符串的指针

    // 动态分配内存并存储字符串
    arr[0] = (char *)malloc(6 * sizeof(char));  // 分配 6 个字符的空间
    strcpy(arr[0], "Hello");

    arr[1] = (char *)malloc(6 * sizeof(char));
    strcpy(arr[1], "World");

    arr[2] = (char *)malloc(12 * sizeof(char));
    strcpy(arr[2], "Programming");

    // 输出指针数组中的字符串
    for (int i = 0; i < 3; i++) {
        printf("%s\n", arr[i]);
    }

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

    return 0;
}

8、指针数组和多维数组

指针数组可以用来模拟多维数组，尤其是在处理不规则数据时非常有用。例如，指针数组可以用于表示行数不固定的二维数组。

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

int main() {
    int rows = 3;
    int *arr[rows];  // 指针数组，表示二维数组的行

    // 为每一行分配不同长度的内存
    arr[0] = (int *)malloc(2 * sizeof(int));  // 第一行有2个元素
    arr[1] = (int *)malloc(3 * sizeof(int));  // 第二行有3个元素
    arr[2] = (int *)malloc(4 * sizeof(int));  // 第三行有4个元素

    // 初始化数据
    for (int i = 0; i < 2; i++) arr[0][i] = i;
    for (int i = 0; i < 3; i++) arr[1][i] = i + 10;
    for (int i = 0; i < 4; i++) arr[2][i] = i + 20;

    // 输出数据
    for (int i = 0; i < 2; i++) printf("%d ", arr[0][i]);
    printf("\n");
    for (int i = 0; i < 3; i++) printf("%d ", arr[1][i]);
    printf("\n");
    for (int i = 0; i < 4; i++) printf("%d ", arr[2][i]);
    printf("\n");

    // 释放内存
    free(arr[0]);
    free(arr[1]);
    free(arr[2]);

    return 0;
}