Assign an array to a pointer with complex cases

Question

if we assign a pointer to another pointer, it's called "swap the pointers". For example,

float *temp, *ptr1, *ptr2;
temp = ptr1;
ptr1 = ptr2;
ptr2 = temp;

However, if we assign an array to a pointer, it's illegal because array is not really the pointer type. But look at the next 3 examples:

float arr[]={1.2, 1.9, 3.1};
float *ptr;
int i;
ptr = (float *)calloc(3,sizeof(float));
ptr = arr;
for (i=0;i<3;i++){
    printf("ptr[%d]=%f\n",i,ptr[i]);
}

This code snippet passed the compilation and ran correctly (illegal code gets the correct answer?):

ptr[0]=1.200000
ptr[1]=1.900000
ptr[2]=3.100000

If I add free(ptr) following the last line, i.e.

float arr[]={1.2, 1.9, 3.1};
float *ptr;
int i;
ptr = (float *)calloc(3,sizeof(float));
ptr = arr;
for (i=0;i<3;i++){
    printf("ptr[%d]=%f\n",i,ptr[i]);
}
free(ptr);  /*add free here*/

This time a warning came up:

warning: attempt to free a non-heap object ‘arr’ [-Wfree-nonheap-object]

---

int i;
int flag=0;
float arr1[3]={1.07,3.01,5.02};
float arr2[3]={2.07,6.01,9.02};
float arr3[3]={3.07,8.01,0.02};
float *ptr;
ptr = (float *)calloc(3,sizeof(float));
if(flag==0){
    ptr = arr1;
}
else if(flag==1){ 
    ptr = arr2;
}
else{ 
    ptr = arr3;
}
for (i=0;i<3;i++){
    printf("ptr[%d]=%f\n",i,ptr[i]);
}

It can run correctly with different flag, but if I add free(ptr) at last line, it still has warning like the previous.

Does anybody help analyze why?

Answer 1

ptr = (float *)calloc(3,sizeof(float));

Here, you set ptr to a block of malloc'ed memory big enough for 3 floats. Then on the next line:

ptr = arr;

You overwrite the value of ptr, causing a memory leak, with arr. This is legal because in an assignment like this an array decays into a pointer to its first element.

When you then print the values that ptr point to, you get the values in arr because that's where ptr points.

This is also why calling free on ptr is invalid since it no longer points to allocated memory.

As for the last bit of code, this is an invalid initializer:

float arr1[3]={{1.07,3.01,5.02}};

When I ran this code, flag=0 showed 0 for the second and third values, while flag=1 and flag=2 showed all the expected values.

You only need one set of braces:

float arr1[3]={1.07,3.01,5.02};

Answer 2

Solution without error

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

int main()
{
    float arr[]={1.2, 1.9, 3.1};
    float *ptr;
    int i;
    ptr = (float *)calloc(3,sizeof(float*));

    if(ptr == NULL){
     perror("calloc");
     return -ENOMEM;
    }
    //ptr = arr;

    // here you need to do something like this
    ptr[0] = arr[0];
    ptr[1] = arr[1];
    ptr[2] = arr[2];

    for (i=0;i<3;i++){
       printf("ptr[%d]=%f\n",i,ptr[i]);

           }
        free(ptr);
}

Answer 3

There's absolutely nothing illegal at all in your code when you point a pointer to an array. It will not even give you a warning.

A pointer is a pointer and it can point at anything. Sometimes you may need to cast it, but pointing at an array of the same base type is not only completely valid, it's even common.

However, you can only use free on memory that's allocated on the heap (malloc, calloc, etc). An array is allocated on the stack and does not need to be freed, and as you have already seen, you will get a runtime error if you do.

Answer 4

Assign an array

In C arrays may not be assigned.

You need to assign element by element.

What happens here

float arr[]={1.2, 1.9, 3.1};
float *ptr;

ptr = arr;

is that you assign to ptr the address of arr[0]. This is called "The array is decayed to a pointer (the address of) it's first element"

No array elements get copied!

To prove this just do

arr[0] = 42.;

next and then run the print-loop

for (int i = 0; i < 3; ++i) 
{
  printf("ptr[%d] = %f\n", i, ptr[i]);
}

you will get (something like):

ptr[0] = 42.000
ptr[1] = 1.9000
...