背景

Question

由于我只是一个学习者，我对上述问题感到困惑。指向数组的指针与指针数组有何不同？请向我解释，因为我必须向老师解释。谢谢。

Answer 1

指向数组的指针

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

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

ptr = &a;

现在ptr指向10个整数的数组。

您需要使用括号ptr以便按以下示例访问数组的元素(*ptr)[i] cosider：

示例代码

#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

Answer 2

指向阵列的指示

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

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

Answer 3

背景

将指针视为一种单独的数据类型。它们有自己的存储要求 - 例如它们的大小 - 它们在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;

Answer 4

指针数组是这样的 - int* arr[3];将包含指向3个不同变量的多个指针指向数组的指针是这样的 - 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

Answer 5

我不确定我的问题是否正确，但我会尝试指出这一点。

指针指向类型
e.g：

int num;
int* p_num = &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 **

Answer 6

在考虑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个指针。< / p>

指向数组和指针数组的指针

6 个答案:

指向数组的指针

指针数组

背景

指向数组的指针

指针数组