C - 函数无意中更改了字符串

Question

I've been using some C lately and I'm relatively new right now. My main problem is that a string I pass to a function is getting changed to a new set of random characters unintentionally. It's difficult for me to explain my problem because I have a bunch of code and I can't share it all. But here are the areas where the problem is:

This code in the main function:

char* name = "@";
Var v = NewVar(name, 0);
printf("%s\n", name);

Prints:

Creating New Value w/ Name: @ 
@

-- which is what it should print. However, this code (in another function):

printf("Before: %s\n", split[counter]);
Var v = NewVar(split[counter], 0);
printf("After: %s\n", split[counter]);

Prints:

Before: hi
Creating New Value w/ Name: �
After:�P�

"split" (from the code above) is just a 2d array defined as such:

char** split = str_split(path, '/')

The "NewVar()" function is the following:

Var NewVar(char *name, int value){
    printf("Creating New Value w/ Name: %s\n", name);
    Var v;
    v.value = value;
    v.name = name;
    v.varsLen = 0;
    v.vars = (Var*)malloc(sizeof(struct Vars));
    return v;
}

I've noticed this problem many times before, but up until now I've had work-arounds. Any advice or explanation as to why this is would be super helpful.

Edit: This is a full working example:

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

char** strSplit(char* base, const char* delim){
    char* result[0];
    char *token;
    char str[strlen(base)];
    strcpy(str, base);
    token = strtok(str, delim); 
    int counter = 0;
    while( token != NULL ) {
        result[counter] = token;
        token = strtok(NULL, delim);
        counter++;
    }
    char** split = malloc(counter * sizeof(char*));
    for(int i = 0; i < counter; i++){
        split[i] = malloc(sizeof(result[i])+1);
        result[i][strlen(result[i])] = '\0';
        split[i] = result[i];
    }
    split[counter] = 0;
    return split;
}

typedef struct Vars{
    char* name;
    struct Vars* vars;
    int value;
    int varsLen;
} Var;

Var NewVar(char *name, int value){
    printf("Creating New Value w/ Name: %s\n", name);
    Var v;
    v.value = value;
    v.name = name;
    v.varsLen = 0;
    v.vars = (Var*)malloc(sizeof(struct Vars));
    return v;
}

void test(char** split){
    char* name = split[0];
    Var v = NewVar(name,0);
    printf("After: %s\n", name);
}

int main(int argc, char const *argv[])
{
    char* name = "@";
    Var v = NewVar(name, 0);
    printf("%s\n", name);
    char** split = strSplit("@/dir1/dir2", "/");
    printf("Before: %s\n", split[0]);
    test(split);
    return 0;
}

That prints:

Creating New Value w/ Name: @
@
Before: @
Creating New Value w/ Name: @
After: 

Answer 1

Let's dissect str_split() , shall we?

char** strSplit(char* base, const char* delim){
    char* result[0];

Our first error. You can't have zero-length arrays. Also, you use the array later, so even if you could have zero-length arrays, you couldn't index into them.

    char *token;
    char str[strlen(base)];
    strcpy(str, base);

Next error. str is too small to hold base , since strlen() doesn't count the null-terminator.

    token = strtok(str, delim); 
    int counter = 0;
    while( token != NULL ) {
        result[counter] = token;

Misuse of result .

        token = strtok(NULL, delim);
        counter++;
    }
    char** split = malloc(counter * sizeof(char*));

Remember this, split has enough space for counter char * s...

    for(int i = 0; i < counter; i++){
        split[i] = malloc(sizeof(result[i])+1);

Mixed up strlen() and sizeof() .

        result[i][strlen(result[i])] = '\0';

Useless. If somestring[strlen(somestring)] wasn't already '\\0' , it wouldn't be strlen(somestring) .

        split[i] = result[i];

This leaks the memory allocated for split[i] and keeps a pointer to str , which goes out of scope when the function returns. Replace with strcpy() .

    }
    split[counter] = 0;

Did you remember how much space split had?

    return split;
}

Answer 2

You don't know what's going to happen to the passed-in value of name . If it was allocated on the stack, it will be overwritten. Use a strcpy when assigning to v.name and you'll be safe.