数组指针

int a[10];
int (*ptr)[10];

这里ptr是一个指向10个整数的数组的指针。

ptr = &a;

现在ptr指向10个整数的数组。
你需要用括号ptr来访问数组中的元素作为(*ptr)[i]，如下面的例子所示：
示例代码

#include<stdio.h>
int main(){
  int b[2] = {1, 2}; 
  int  i;
  int (*c)[2] = &b;
  for(i = 0; i < 2; i++){
     printf(" b[%d] = (*c)[%d] = %d\n", i, i, (*c)[i]);
  }
  return 1;
}

输出：

b[0] = (*c)[0] = 1
 b[1] = (*c)[1] = 2

指针数组

int *ptr[10];

这里ptr[0],ptr[1]....ptr[9]是指针，可以用来存储变量的地址。
示例：

main()
{
   int a=10,b=20,c=30,d=40;
   int *ptr[4];
   ptr[0] = &a;
   ptr[1] = &b;
   ptr[2] = &c;
   ptr[3] = &d;
   printf("a = %d, b = %d, c = %d, d = %d\n",*ptr[0],*ptr[1],*ptr[2],*ptr[3]);
}

输出：a = 10，B = 20，c = 30，d = 40

后台

可以将指针看作是一种单独的数据类型。它们有自己的存储需求--比如它们的大小--它们在x86_64平台上占用8个字节。这就是void指针void*的情况。
在这8个字节中，存储的信息是另一段数据的存储器地址。
关于指针的事情是，因为它们“指向”另一段数据，所以知道数据的类型也很有用，这样你就可以正确地处理它（知道它的大小和结构）。
而不是有自己的数据类型名称，如pointer，他们根据他们引用的数据类型组成自己的名称，如int*，一个指向整数的指针。如果你想要一个不附加类型信息的普通指针，你可以选择使用void*。
因此，基本上每个指针（指向int，char，double）都只是一个void*（大小相同，用途相同），但编译器知道所指向的数据是int类型，并允许您相应地处理它。

/**
 *  Create a new pointer to an unknown type.
 */
void* data;

/**
 *  Allocate some memory for it using malloc
 *  and tell your pointer to point to this new
 *  memory address (because malloc returns void*).
 *  I've allocated 8 bytes (char is one byte).
 */
data = malloc(sizeof(char)*8);

/**
 *  Use the pointer as a double by casting it
 *  and passing it to functions.
 */
double* p = (double* )data;
p = 20.5;
pow((double* )data, 2);

数组指针

如果你在内存中有一个值数组（比如说整数），指向它的指针就是一个包含它地址的变量。
您可以通过首先取消引用指针，然后对数组及其值进行一些操作来访问此值数组。

/**
 *  Create an array containing integers.
 */
int array[30];
array[0] = 0;
array[1] = 1;
...
array[29] = 29;

/**
 *  Create a pointer to an array.
 */
int (*pointer)[30];

/**
 *  Tell the pointer where the data is.
 */
pointer = &array;

/**
 *  Access the data through the pointer.
 */
(*pointer)[1] = 999;

/**
 *  Print the data through the array.
 *  ...and notice the output.
 */
printf("%d", array[1]);

指针数组

如果你有一个指向值的指针数组，整个指针数组是一个变量，数组中的每个指针都指向内存中某个值所在的位置。
你可以访问这个数组和它里面的指针而不需要解引用它，但是为了从它得到某个值，你必须解引用数组里面的一个指针。

/**
 *  Create an array containing pointers to integers.
 */
int *array_of_pointers[30];
array_of_pointers[0] = 0;
array_of_pointers[1] = 1;
...
array_of_pointers[29] = 29;

指向数组的指针

数组的指针将指向数组的起始地址。

int *p; // p is a pointer to int
int ArrayOfIntegers[5]; // ArrayOfIntegers is an array of 5 integers, 
                        // that means it can store 5 integers.

p = ArrayOfIntegers; // p points to the first element of ArrayOfIntegers

• 指针阵列 *

指针数组将包含指向不同变量的多个指针。

int* ArrayOfPointers[2]; // An array of pointers which can store 2 pointers to int
int A = 1;
int B = 2;
int *PointerToA ;
PointerToA  = &A ; // PointerToA is a pointer to A
int *PointerToB ; 
PointerToB  = &B ; // // PointerToA is a pointer to A
ArrayOfPointers[0] = PointerToA ; // ArrayOfPointers first element points to A
ArrayOfPointers[1] = PointerToB ; // ArrayOfPointers second element points to B

我不确定我是否回答对了这个问题，但我会试着指出这一点。
有指向类型的指针
例如：

int num;
int* p_num = # // this is pointing at the int

此外，还有数组（实际上是指针）

int num;    // an Integer
int* p_num; // a pointer. (can point at int's)
int arr[3]; // an Array holding 3 int's
arr[0] = 1; // + holding the values 1, 2, 3
arr[1] = 2;
arr[2] = 3;

p_num = arr; // because an array is just a pointer "p_num" num is now pointing at
             // + the first element in the array.
             // + ** THIS IS NOW A POINTER TO AN ARRAY **
num = *p_num;// num = 1

还有一些数组，可以保存多个指针：

int num1;
int num2;
int num3;

int* p_array[3];    // an array holding 3 pointer to int's
p_array[0] = &num1; // this is pointing at num1
p_array[1] = &num2; // num2, ...
p_array[2] = &num3;
                    // ** THAT IS AN ARRAY OF POINTERS **

在考虑c指针时，我经常求助于笔和纸。

数组指针

[a] -> [b]
       [c]
       [d]
        .
        .
        .

指针数组

[a] -> [j]
[b] -> [k]
[c] -> [l]
 .      .
 .      .
 .      .

指向数组的指针包含数组的内存位置。而指针数组包含大量的内存位置，这些位置包含单个值（或可能是其他数组，或指针数组;）.

数组指针

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

void main(void) {
    int i;
    int *ptr, *loopPtr;
    ptr = malloc(10 * sizeof(int)); // allocate an array of 10 ints on the heap

    loopPtr = ptr;            // copy pointer into temp pointer 
    for(i=0; i < 10; i++) {
        *loopPtr = i;         // dereference pointer and store i in it
        loopPtr++;            // move pointer to next memory location
    }

    loopPtr = ptr;            // copy pointer into temp pointer
    for(i=0; i < 10; i++) 
        printf("%d, ",*(loopPtr++)); // move across array printing
    printf("\n");
    free(ptr);               // free memory allocated on the heap
}

指针数组

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

void main(void) {
    int i;
    int *ptr[10];            // an array of pointers

    // allocate 10 ints on the heap pointed to by an array
    for(i=0; i < 10; i++)
        ptr[i] = malloc(sizeof(int));

    for(i=0; i < 10; i++)
        *ptr[i] = i;         // dereference pointer and store i in it

    for(i=0; i < 10; i++)    // iterate through array and dereference pointers
        printf("%d, ",*ptr[i]);
    printf("\n");

    for(i=0; i < 10; i++)
        free(ptr[i]);
}

对比这种差异的最好方法可能是malloc()调用，一个返回指向10个ints数组的指针，另一个返回指向单个ints的10个指针。

一个指针数组是this -int* arr[3];将包含多个指向3个不同变量的指针指向一个数组的指针是this -int (*arr)[3];将指向3个元素的数组的第一个元素
下面是一个示例代码，可能会对你有更多帮助

int array[3];
array[0] = 1;
array[1] = 2;
array[2] = 3;

int* point = array; // pointer of an array

int* points[3];

points[0] = &array[0];
points[1] = &array[1];
points[2] = &array[2]; // an array of pointer