为什么我的函数不能调整指针的内容，除非我返回一个指针来分配它

Question

My question is what is the difference between these two? one is a void, and another one returns a 2d array, they however do the same but the functionality doesn't seem to do the same? i must be misunderstanding pointers here.

I thought pointers stored nothing but an adress to point to, so if i pass one as a parameter, and change the contents and to where it points, don't i do the same as re-assigning it to the functions return value.

on the end of both functions we print the first line, they did so on both. but whilst printing the adjusted grid by the void function in my Main i get a segfault.

char    **ft_grid_gen(int size)
{
    char    **map;
    int     index;
    int     elem_index;
    int     sq_root;

    index = 0;
    elem_index = 0;
    sq_root = ft_sqrt(size * 4);
    map = (char**)malloc(sq_root * sizeof(char *));
    while (index < sq_root)
    {
        map[index] = (char*)malloc(sq_root * sizeof(char));
        while (elem_index < sq_root)
        {
            map[index][elem_index] = '.';
            elem_index++;
        }
        index++;
        elem_index = 0;
    }
    printf("GENERATED NEW GRID of size %s!\n", map[0]);
    return (map);
}

void    ft_grid_gen(char **map, int size)
{
    int     index;
    int     elem_index;
    int     sq_root;

    index = 0;
    elem_index = 0;
    sq_root = ft_sqrt(size * 4);
    map = (char**)malloc(sq_root * sizeof(char *));
    while (index < sq_root)
    {
        map[index] = (char*)malloc(sq_root * sizeof(char));
        while (elem_index < sq_root)
        {
            map[index][elem_index] = '.';
            elem_index++;
        }
        index++;
        elem_index = 0;
    }
    printf("GENERATED NEW GRID of size %s!\n", map[0]);
}

Answer 1

Note that ft_grid_gen don't just change that to which map points; it also change map itself.

Changing map has no more effect on the caller than changing size . Whatever variable you used as a parameter in the caller still point to "nowhere useful" after ft_grid_gen .

If you want to return a value via a parameter, you need to pass a pointer to the variable that will receive the value.

void f(int *i_ptr) {
   *i_ptr = 123;
}

int i;
f(&i);

In your case, this would be

void ft_grid_gen(char ***map_ptr, int size) {
   ...
   *map_ptr = map;
}

char **map;
f(&map);

Alternatively, you could allocate the memory on the outside. Since the function no longer has a need to change map , the value of map can be passed directly.

void ft_grid_gen(char **map, int size) {
   ...
}

char **map = malloc(ft_sqrt(size * 4) * sizeof(char*));
ft_grid_gen(map, size);

(Obviously, this approach is far from ideal in this specific situation.)

Answer 2

The difference is that the first function returns something you can use later on. In the second function, you pass in a char** by value, and then with:

map = (char**)malloc(sq_root * sizeof(char *));

You assign a new value to the local variable map , which was assigned its first value through the function parameter. However this does not affect the original char** variable in main() -- because it was passed in by value like everything else in C. If you wanted to change the main() variable, you would have passed a pointer to it (ie char*** ) and de-referenced it in this function, like:

*map = (char**)malloc(sq_root * sizeof(char *));