将函数返回的指针设置为某个地址C

Question

I was writing some C code and I got the following problem. Suppose we have this really simple program:

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

struct this {
    char* str;
};

char* freeStrReturnPointer(struct this * t) {
    free(t->str);
    return t->str;
};

int main() {
    // standard mallocing going on
    struct this* t = malloc(sizeof(struct this));
    t->str = malloc(sizeof(char)*10);
    // here is the problematic part!
    freeStrReturnPointer(t) = NULL;
    // end of problematic part
    free(t);
    exit(0);
}

Compilation gives the following problem:

test.c: In function ‘main’:
test.c:18:29: error: lvalue required as left operand of assignment
     freeStrReturnPointer(t) = NULL;

My question is: If the function freeStrReturnPointer returns a pointer char*, why can I not set it to NULL? The following would definitely work:

char* p;
p = NULL;

What is the difference here? Why can I not assign a value to the returned pointer immediately?

Caveat: I realize I can just set the pointer to null in the function, but that is not the point of the question.

Answer 1

You can't do that because the expression freeStrReturnPointer(t) returns an r-value, which needs to be assigned to a variable in order for its lifetime to extend beyond the full expression that contains it. Assigning it to "null" literally has no visible side effects and is most likely a programmer mistake, so the language treats it as an error.

Instead you should do

char * p = freeStrReturnPointer(t);
p = NULL;

Then, in both expressions p is the l-value, and freeStrReturnPointer(t) is the r-value in the first, and NULL is the r-value in the second.

Alternatively, you could treat freeStrReturnPointer(t) as a void function and just ignore the result (since you don't use it anyways, there's no reason to set it to NULL ):

(void) freeStrReturnPointer(t);

Answer 2

I think what you mean to do is return a pointer to the pointer, then dereference that and set the original pointer to NULL .

so in your code I would write:

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

struct this {
    char* str;
};

char** freeStrReturnStrPointer(struct this * t) {
    free(t->str);
    return &t->str;
};

int main(){
    struct this* t = malloc(sizeof(struct this));
    t->str = malloc(sizeof(char)*10);
    *freeStrReturnStrPointer(t) = NULL;
    free(t);
}

Which would set str to NULL after freeing it.

currently you are just returning the actual pointer to char , not a pointer to the storage of the pointer to char .

Answer 3

Well, what you're trying to do is equivalent of the following:

char *p = freeStrReturnPointer(t); 
p = NULL; 

which will not reset t->str ! Your freeStrReturnPointer() function is returning a char* value that points to a string. If you assign to it, then you overwrite where it points to, making it useless code.

If you do:

char *p = freeStrReturnPointer(t); 
printf("%p\n", t->str);
p = NULL; 
printf("%p\n", t->str);

You'll get:

0x012345678901
0x012345678901

as output.

If you want to reset t->str you then need to use a double pointer:

char** freeStrReturnPointer(struct this * t) {
    free(t->str);
    return &(t->str);
};

and within main():

char **p = freeStrReturnPointer(t);
printf("%p\n", t->str);
*p = NULL;
printf("%p\n", t->str);

which will then output something like:

0x012345678901
0x0

Answer 4

freeStrReturnPointer() is returning a value (right value to be more precise). In your case it's a pointer but a value nonetheless. As the compiler is telling you, you are basically trying to alter the way the = operator is working. Assignment operator requires a variable of some sort on the left and a value (which can again be a variable) on the right. Your problem here is not restricted to pointers. Try using even basic types or an object and you will still get this error.

Answer 5

It seems that in the freeStrReturnPointer(struct this * t) what you do with t->str has no incidence on the variable that you created in main, and what you return is actually an rvalue (and you cannot assign something to an rvalue). I would use a pointer to pointer instead : freeStrReturnPointer(struct this ** t)