Pointer to an array and Array of pointers

前端 未结 6 2030
感动是毒
感动是毒 2020-12-22 00:47

As I am just a learner, I am confused about the above question. How is a pointer to an array different from array of pointers? Please explain it to me, as I will have to exp

相关标签:
6条回答
  • 2020-12-22 01:28

    POINTER TO AN ARRAY

    Pointer to an array will point to the starting address of the array.

    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
    

    ARRAY OF POINTERS

    Array of pointers will contain multiple pointers pointing to different variables.

    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
    
    0 讨论(0)
  • 2020-12-22 01:29

    Pointer to an array

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

    Here ptr is an pointer to an array of 10 integers.

    ptr = &a;
    

    Now ptr is pointing to array of 10 integers.

    You need to parenthesis ptr in order to access elements of array as (*ptr)[i] cosider following example:

    Sample code

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

    Output:

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

    Array of pointers

    int *ptr[10];
    

    Here ptr[0],ptr[1]....ptr[9] are pointers and can be used to store address of a variable.

    Example:

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

    Output: a = 10, b = 20, c = 30, d = 40

    0 讨论(0)
  • 2020-12-22 01:36

    I'm not sure if i get the question right but I will try to point this out.

    There are pointers pointing to a type
    e.g.:

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

    Moreover there are arrays (which in fact are pointers)

    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
    

    And there are arrays, which can hold multiple pointers:

    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 **
    
    0 讨论(0)
  • 2020-12-22 01:37

    I often resort to pen and paper when thinking about c pointers.

    Pointer to an array

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

    An array of pointers

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

    A pointer to an array contains the memory location of an array. Whereas an array of pointers contains lots of memory locations, which contain single values (or possibly other arrays, or arrays of pointers ;).

    Pointer to an array

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

    An array of pointers

    #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]);
    }
    

    The best way to contrast the difference is probably with the malloc() calls, one returns a pointer to an array of 10 ints and the other returns 10 pointers to individual ints.

    0 讨论(0)
  • 2020-12-22 01:44

    Background

    Think of pointers as just a separate data type. They have their own storage requirements -- such as their size -- they occupy 8 bytes on a x86_64 platform. This is the case of void pointers void*.

    In those 8 bytes the information stored is the memory address of another piece of data.

    The thing about pointers is that since they "point" to another piece of data, it's useful to know what type that data is too so you can correctly handle it (know its size, and structure).

    In stead of having their own data type name such as pointer they compose their name based on the data type they refer to such as int* a pointer to an integer. If you want a plain pointer without type information attached to it you have the option of using void*.

    So basically each pointer (to int, to char, to double) is just a void* (same size, same use) but the compiler knows the data being pointed to is of type int and allows you to handle it accordingly.

    /**
     *  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);
    

    Pointer to array

    If you have an array of values (let's say integers) somewhere in memory, a pointer to it is one variable containing its address.

    You can access this array of values by first dereferencing the pointer and then operating some work on the array and its values.

    /**
     *  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]);
    

    Array of pointers

    If you have an array of pointers to values, the entire array of pointers is one variable and each pointer in the array refers to somewhere else in the memory where a value is located.

    You can access this array and the pointers inside it without dereferencing it but in order to reach a certain value from it you will have to dereference one of the pointers inside the array.

    /**
     *  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;
    
    0 讨论(0)
  • 2020-12-22 01:45

    An array of pointers is this - int* arr[3]; will contain multiple pointers pointing to 3 different variables Pointer to an array is this - int (*arr)[3]; will point to first element of an array of 3 elements

    Below is a sample code which might help you more

        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
    
    0 讨论(0)
提交回复
热议问题