C变量未初始化

Question

When debugging the following code snippet, I observed that function = copy_string(temp_function); does not initialize the variable function (still points at 0x0), even though on return copy copy from copy_string() points to an initialized memory address containing the correct result.

static char* copy_string(char* string)
{
    char* copy = NULL;
    uint32_t length = 0U;

    length = strlen(string);
    copy = malloc(sizeof(char) * (length +1));
    strcpy(copy, string);

    return copy;
}

static void separate_test(const char* test_name, char* function, char* scenario, char* expected_result)
{
    const char* delimiter = "__";
    char* new_test_name = NULL;
    char* temp_function = NULL;
    char* temp_scenario = NULL;
    char* temp_expected_result = NULL;
    uint32_t length = strlen(test_name);

    new_test_name = malloc(sizeof(char) * (length +1));
    strcpy(new_test_name, test_name);
    temp_function = strtok(new_test_name, delimiter);
    function = copy_string(temp_function);
    temp_scenario = strtok(NULL, delimiter);
    scenario = copy_string(temp_scenario);
    temp_expected_result = strtok(NULL, delimiter);
    expected_result = copy_string(temp_expected_result);
}

The function is called with the following parameters:

const char* test_name = "function_name__scenario__expected_result";
char* function = NULL;
char* scenario = NULL;
char* expected_result = NULL;

separate_test(test_name, function, scenario, expected_result);

What is the cause of this behavior?

Edit: Fixed allocation issue.

Answer 1

You are setting the value of function and other variables in separate_test . However, since they are passed by value, that does change the values of those variables in the calling function.

Answer 2

You need to reserve space for the null terminator. This line:

copy = malloc(sizeof(char) * length);

Should be:

copy = malloc(length + 1);

sizeof(char) is always 1, so you don't need it here.

Also, recall that parameters in C are passed by value, so the changes you make to test_name , function , etc, inside separate_test() are not seen by the caller. You might want to pass pointers to pointers instead, like so:

const char* test_name = "function_name__scenario__expected_result";
char* function = NULL;
char* scenario = NULL;
char* expected_result = NULL;

separate_test(test_name, &function, &scenario, &expected_result);

separate_test() becomes:

static void separate_test(const char* test_name, char** function, char** scenario, char** expected_result)
{
    const char* delimiter = "__";
    char* new_test_name = NULL;
    char* temp_function = NULL;
    char* temp_scenario = NULL;
    char* temp_expected_result = NULL;
    uint32_t length = strlen(test_name);

    new_test_name = malloc(length+1);
    strcpy(new_test_name, test_name);
    temp_function = strtok(new_test_name, delimiter);
    *function = copy_string(temp_function);
    temp_scenario = strtok(NULL, delimiter);
    *scenario = copy_string(temp_scenario);
    temp_expected_result = strtok(NULL, delimiter);
    *expected_result = copy_string(temp_expected_result);
}

Answer 3

That is because the function parameter in seperate_test is a temporary variable. So it takes a random address to which it points to, since the before calling it the variable is initialized to NULL. Si I would advise to make a : function = malloc(sizeof(function)) before calling the function or returning the function parameter.