C语言中,指针数组 是一种特殊的数据结构,其中每个元素都是一个指针,指针指向某种类型的数据。指针数组可以存储多个指针,通常用于存储多个字符串、函数地址,或者指向不同变量的指针。指针的数组,实际是一个数组,长度由数组本身决定,这个数组的所有元素都是指针类型,存放的都是地址。指针数组是一个由指针变量组成的数组,也就是说其中的元素都是指针变量。本文主要是C语言指针数组和数组指针及区别。

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;
}

推荐文档