How does free() works in this case? [closed] - c

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 2 years ago.
Improve this question
Let's say a function allocates memory for a string and returns it.
The variable, that calls that function, in which is stored its return string is an array of pointers to char already dynamically allocated.
My doubt is, when I'll free the variable's memory, is it going to free both the variable memory and the in-function string memory or does the in-function allocated memory became one with the variable one?
char *function() {
//allocates memory for <string>
return <string>
}
int main() {
//<variable> declaration
//<variable> allocation
<variable> = function();
free(<variable>);
return 0;
}
For practical reasons I omitted the //function declaration part
Thanks for your attention and help!

Answer 1

There are two possible cases:
Function allocates memory using dynamic memory allocation and it is 100% correct
char *func(void)
{
char *x = malloc(100);
/* some code */
return x;
}
void foo(void)
{
char *y = func();
free(y);
}
Other ways of allocating memory. All invoke the undefined behavior when you try to free them. Additionally there is an another UB when pointer to automatic variable is used outside the scope it was defined in.
char w[100];
char *func(void)
{
char x[100];
/* some code */
return x;
}
char *func1(void)
{
static char x[100];
/* some code */
return x;
}
char *func2(void)
{
return w;
}
void foo(void)
{
char *y = func();
y[0] = 'a'; //UB
free(y); //UB
y = func1();
y[0] = 'a';
free(y); //UB
y = func2();
y[0] = 'a';
free(y); //UB
}

Answer 2

I posted a complete example of it here: https://stackoverflow.com/a/63756135/11234199
My doubt is, when I'll free the variable's memory, is it going to free both the variable memory and the in-function string memory or does the in-function allocated memory became one with the variable one?
Please run the program provided there since it will do just this: create and destroy a block of pointers to char, just like argc/argv block that every main() function gets for free in C
The program I posted there shows how to build dynamically a block of strings and how to consume it, allocating memory in blocks and trimming it at the end for the exact used size
But here I will provide a 20-line example that builds an array of pointer the same way
Your function
char *function()
{
//allocates memory for <string>
return <string>
}
returns just one pointer to a char. You could write
char one_char = *function();
and it is just what is is. There is not string in C in fact. And if function is char* then *function is char.
Inside the function you can malloc() a block and return the address in the function, with a convenient '\0' at the start of a 1MB block and it would be fine.
For this thing to work we need to build it carefully
Fact is that in general we want something like
typedef struct
{
int argc;
char** argv;
} stringArray;
just like the familiar main() prototype.
And why is that?
Well, we want an array of pointers to char due to the conveniente of iterate through hem just like an ordinary array like argv[0], argv[1]...
But it is essential the argc thing. As in
char** argv;
we have no way to know how many pointers are in the area pointed by *argv.
we just know that
argv is char**
*argv is char*, a pointer to char
**argv is a char, a single char
we have to build the block the way we need, or just hope that someone gently did that before we use.
If there are one hundred strings at *argv it is because someone allocated 100 pointers to char and put the address in argv. And after that allocated 100 strings of who knows what size, using the one hundred pointers. And then made sure the strings are all null-terminated.
This is how it works.
The code below builds an example 10-string block, and just for fun the strings are build the way we see here:
we got 10 strings:
'0' [len: 1]
'01' [len: 2]
'012' [len: 3]
'0123' [len: 4]
'01234' [len: 5]
'012345' [len: 6]
'0123456' [len: 7]
'01234567' [len: 8]
'012345678' [len: 9]
'0123456789' [len: 10]
End of list
And back in main() the the full block is destroyed from inside out.
here is the code
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{
int argc;
char** argv;
} stringArray;
stringArray* get_the_block(void);
int main(void)
{
stringArray* string_array = get_the_block();
printf("we got %d strings:\n\n", string_array->argc);
char** array = string_array->argv; // just for readability
for (int i = 0; i < string_array->argc; i += 1)
printf("'%s' [len: %zd]\n", array[i], strlen(array[i]));
printf("\nEnd of list\n");
// free() the block
// since string_array is also a pointer we have 3 levels
// 1st free() the strings
for (int i = 0; i < string_array->argc; i += 1)
free(array[i]);
// 2nd free() the block of pointers
free(string_array->argv);
// 3rd free() the control structure
free(string_array);
return 0;
}; // main()
stringArray* get_the_block(void)
{
// this is an useless example
// it builds a 10-string block and
// return it
const char* text = { "0123456789" };
// building the block of strings
// "0", "01", "012" ... "123456789"
char** string = (char**)malloc(10 * sizeof(char*));
for (int i = 0; i < 10; i += 1)
{
string[i] = malloc((1 + 1 + i) * sizeof(char));
memcpy(string[i], text, 1 + i);
string[i][i + 1] = 0; // strings are null-terminated
};
// builds the struct to return, just like the system
// does for main()
stringArray* block = (stringArray*)malloc(sizeof(stringArray));
block->argc = 10;
block->argv = string;
return block;
};

Answer 3

The variable, that calls that function, in which is stored its return
string is an array of pointers to char already dynamically allocated.
It means that the returned pointer from the function can be assigned only to one element of the dynamically allocated array.
For example
char **s = malloc( 10 * sizeof( char * ) );
s[0] = function();
So you may free the memory allocated in the function and the pointer to which was assigned to the element s[0] like
free( s[0] );
After that you may for example reassign the pointer with an address of other dynamically allocated string.
But this call will not free the memory allocated for the whole array of pointers s. To free it you have to write
free( s );