将指针分配给函数或将其地址作为函数参数传递之间有什么区别吗？

Question

I really don't know how to ask it more properly, but I will try to explain my problem.

Lets say we have the following:

int *ptr = foo(&ptr);

This for me I believe it means that, there is a declaration with initialization to the function foo with the pointer it self used as function argument.

Now the following:

int *ptr = foo();

I think is the same, but without any function argument, which means that, the function foo doesn't take any arguments.

Now lets take a look at the following two programs:

Program 1:

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

#define SIZE 3

int *foo(int **ptr);

int main(void){
    int *ptr = foo(&ptr);

    for (int i=0 ; i<SIZE ; i++){
        *(ptr + i) = i + 1;
    }

    for (int j=0 ; j<SIZE ; j++){
        printf("%d\n",*(ptr + j));
    }

    free(ptr);
}

int *foo(int **ptr){
    *ptr = malloc(SIZE * sizeof(*ptr));
    if(*ptr == NULL){
        printf("Error, malloc\n");
        exit(1);
    }
    return *ptr;
}

Program 2:

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

#define SIZE 3

int *foo(void);

int main(void){
    int *ptr = foo();

    for (int i=0 ; i<SIZE ; i++){
        *(ptr + i) = i + 1;
    }

    for (int j=0 ; j<SIZE ; j++){
        printf("%d\n",*(ptr + j));
    }

    free(ptr);
}

int *foo(void){
    int *ptr = malloc(SIZE * sizeof(*ptr));

    if(ptr == NULL){
        printf("Error, malloc\ņ");
        exit(1);
    }
    return ptr;
}

What is the differences/benefits of program 1 or program 2 .

Is the pointer in the first or second program somehow different affected? Or is there any reason of using program 1 or program 2 ?

I'm asking, because the way how to program behaves looks that program 1 and program 2 are the same.

EDIT: I know that the fist program has the pointer ptr modified by the foo function and in the second one I declare it inside the Function foo , but this is not my Question.

Answer 1

The only practical difference between the programs is that the first one could allocate double the amount of memory compared to the second.

In the first program you use *ptr to get the size, but *ptr is of type int * which on a 64-bit system is usually 64 bits. In the second program *ptr is an int and the size of an int is usually 32 bits on both 32 and 64 bit systems.

Since the first program emulates passing by reference, you could use it without using the returned pointer, and in fact it doesn't have to return a value at all and could be declared as returning void . Which one is preferred is a personal choice, I personally prefer the second alternative, but it also depends on use-case.

Answer 2

In first program, you alloc SIZE * sizeof(int *) bytes, and use that memory as if it was SIZE * sizeof(int) long. That means that if you had sizeof(int *) < sizeof(int) you would run in a buffer overflow.

Another problem is that in int *ptr = foo(&ptr); you are modifying the variable ptr twice in one single expression, which is bad because you cannot know which one occurs first. But as you normally write same value it should be ok here.

Another difference is that in first program, you set the value of ptr to NULL in case of allocation error before calling exit() , while in the second, the variable remains uninitialized. But as you use exit in that case, the ptr variable immediately vanishes and could not be used even in an atexit registered function.

IMHO provided you fix first program by using *ptr = malloc(SIZE * sizeof(int)); or *ptr = malloc(SIZE * sizeof(**ptr)); , the 2 versions behave the same.