Question

I’m C# man, new in C language working with points first time.

I have this function that works with malloc(), realloc() and free() at future:

char ** split(char * delimiter, char * input) {

        int i = 0;
        int size = sizeof(char *);
        char ** tokens;
        char * token;
        char * state; 
        tokens = (char **) malloc(size);

        if(tokens == NULL) {
            printf("Allocation failed.");
            return;
        }

        for(token = strtok_r(input, delimiter, &state); 
             token != NULL;
             token =  strtok_r(NULL, delimiter, &state),
             i++, size *= i) {

             tokens = (char **) realloc(tokens, size);

             if(tokens == NULL) {
                printf("Realloc failed.");
                return;
             }

             tokens[i] = state;
        }

        return tokens;
}

when I call:

char * IPNumber = "127.0.01";
char * delimiter = "."; 
char ** parts = split(delimiter, IPNumber);

it gives segmentation fault.

I’m looking for an explanation how to get(calculate) the size value to be used in the second argument of realloc() function. Thanks in advance.

Answer 1

Complete rewrite. There are some issues with the original code as posted.

• The reallocation size computation is incorrect.
• The passing of a string constant to strtok_r is not valid. It modifies the first argument, so that could result in an access violation when passed the string literal.
• The assignment of the token into the result array starts at position 1 instead of 0.
• The assignment uses the state variable instead of the token (probably not at all the desired result and probably undefined behavior).
• There is no way for the caller to know how many tokens are in the returned array.
• A failed call to realloc does not free the original pointer, so it would leak.

So rather than attempt to describe the changes, I’ll follow the same pattern as others and show what might be a cleaner implementation with a single allocation based on the max possible number of tokens.

char ** split(char * delimiter, char * input) {
    int size;
    int maxsize;
    char ** tokens;
    char * token;
    char * state;

    // compute max possible tokens, which is half the input length.
    // Add 1 for the case of odd strlen result and another +1 for
    // a NULL entry on the end
    maxsize = strlen( input ) / 2 + 2;
    tokens = (char**)malloc( maxsize * sizeof( char*) );
    if(tokens == NULL) {
        printf("Allocation failed.");
        return NULL;
    }

    size = 0;
    for(token = strtok_r(input, delimiter, &state);
         token != NULL;
         token =  strtok_r(NULL, delimiter, &state) ) {

         tokens[size++] = token;
    }

    assert( size < maxsize );
    // Put a NULL in the last entry so the caller knows how many entries
    // otherwise some integer value would need to be returned as an output
    // parameter.
    tokens[size] = NULL;

    // NOTE: could use realloc from maxsize down to size if desired

    return tokens;
}

Usage might look like the following. Note the use of strdup to avoid passing the string constant to the function:

char * IPNumber = strdup( "127.0.01" );
char * delimiter = ".";
char ** parts = split(delimiter, IPNumber);
int i;

if ( parts ) {
   for ( i = 0; parts[i] != NULL; i++ )
      printf( "%s\n", parts[i] );

   free( parts );
   }

free( IPNumber );