释放c中的char指针会导致segfault

Question

The subject says all, here's the relevant code written in a simple file.

char* fn = NULL;
SDL_Log("fn pre address is: %p\n",fn);
fn = get_resource("test.txt");
SDL_Log("fn pos address is: %p\n",fn);
//free(fn); <--this causes seg fault if I uncomment it

INFO: fn pre address is: 0x0
INFO: fn pre address is: 0x7fa882501a00
INFO: fn pos address is: 0x7fa882501a00

get_resource(const char* filename) {
    char* string = (char*)calloc(1, sizeof(strlen(res_dir) + strlen(filename)));
    //i also tried with strncpy
    //strncpy(string, res_dir, strlen(res_dir));
    //strncpy(string + strlen(res_dir), filename, strlen(filename));

    memcpy(string, "/usr/test/files", strlen(res_dir));
    memcpy(string + strlen("/usr/test/files"), filename, strlen(filename));
    string[strlen(filename) + strlen("/usr/test/files")] = '\0';
    return string;
}

getting the same behavior. If I free the allocated string I will get a seg fault. Also it doesn't always happen either which is strange.

Answer 1

char* string = (char*)calloc(1, sizeof(strlen(res_dir) + strlen(filename)));

This line doesn't make any sense, sizeof is an operator for determining the storage size needed for a type or an expression of some type.(*)

What you want is something like:

char* string = calloc(1, strlen(res_dir) + strlen(filename) + 1);

Note the + 1 there, it reserves space for the terminating 0 byte in a c-style string. Also note casting of a void * pointer (as returned by malloc() and friends in C) doesn't make sense. It's necessary in C++, but in C, void * is the generic pointer type and implicitly converts to any other data pointer type.

Digging further into your code (as per alk's comment) ... I guess res_dir is just "/usr/test/files" ? You might be missing a slash here (depending on the contents of your filename ) but in general, for concatenating strings, there is already a function in the C language, declared in string.h . Just write something as simple as that:

char* string = calloc(1, strlen(res_dir) + strlen(filename) + 1);
strcpy(string, res_dir);
strcat(string, filename);

and you're done. Note you don't even need calloc() with this method, malloc() will do fine.

---

(*) adding here even a bit more explanation: You probably see sizeof quite often used with memory allocations, for obvious reasons. What you want is to reserve memory for the type char . And you want some count of char s to fit into this memory. So, the correct formula for that would be something like:

malloc( (strlen(res_dir) + strlen(filename) + 1) * sizeof(char) )

Then why leave out the sizeof(char) ? That's because the size of a char is actually defined to be 1 . x * 1 is still x , so no need to use sizeof here :)

Answer 2

First of all this statement

char* string = (char*)calloc( 1, sizeof(strlen(res_dir) + strlen(filename)));

is incorrect. Expression

sizeof(strlen(res_dir) + strlen(filename))

is equivalent to

sizeof( size_t )

and can be equal either 4 or 8 depending on the used environment. More over this expression

sizeof(strlen(res_dir) + strlen(filename))

is unevaluated . That is function strlen is not called in this expression.

A correct statement can look like

char *string = calloc( strlen( res_dir ) + strlen( filename ) + 1, sizeof( char ) );

Take into acount that you need also reserve memory for the terminating zero.

However even this statement is incorrect.:)

Consider what you are trying to do

memcpy(string, "/usr/test/files", strlen(res_dir));
memcpy(string + strlen("/usr/test/files"), filename, strlen(filename));

As you passed string "test.txt" then you will get

"/usr/test/filestest.txt"

I think you mean instead the following

"/usr/test/files/test.txt"

If so then the memory allocation must look like

char *string = calloc( strlen( res_dir ) + strlen( filename ) + 2, sizeof( char ) );

In this case you could write simply

strcpy( string, "/usr/test/files" );
strcat( string, "/" );
strcat( string, filename );

and in this case statement

string[strlen(filename) + strlen("/usr/test/files")] = '\0';

must be removed.