将字符串拆分为数组中的单词，而不使用 C 中的任何预制函数

Question

I am trying to create a function that takes a string , splits it into words and return an array with the words in it. I am not allowed to use any pre-made functions other than malloc within the splitting function. Finally I have to set my function in this form char **ft_split_whitespaces(char *str) My current output looks like that:

    d this is me
    s is me
    s me
    r

Expected output:

    Hello
    World
    This
    Is
    Me

my full code is in the following codes:

    #include <stdio.h>
    #include <stdlib.h>
    
    int     count_words(char *str)
    {
        int i; 
        int word;
        
        i = 0;
        word = 1;
        while(str[i]!='\0')
        {
            if(str[i]==' ' || str[i]=='\n' || str[i]=='\t' 
            || str[i]=='\f' || str[i]=='\r' || str[i]=='\v')
                word++;
            i++;
        }
        return (word);
    }
    
    char    **ft_split_whitespaces(char *str)
    {
        int index;
        int size;
        int index2;
        char **arr;
        
        index = 0;
        index2 = 0;
        size = count_words(str);
        arr = (char **)malloc(size * sizeof(char));
        if (arr == NULL)
            return ((char **)NULL);
        while (str[index])
        {
            if(str[index] == ' ')
            {
                index++;
                value++;
                index2++;
            }
            else
                *(arr+index2) = (char*) malloc(index * sizeof(char));
                *(arr+index2) = &str[index];    
            index++;
        }
        **arr = '\0';
        return (arr);
    }
    
    int main()
    {
        char a[] = "Hello World This Is Me";
        char **arr;
        int i;
        int ctr = count_words(a);
        arr = ft_split_whitespaces(a);
        
        for(i=0;i < ctr;i++)
            printf("%s\n",arr[i]);
        return 0;
    }

Answer 1

You have quite a few errors in your program:

1. arr = (char **)malloc(size * sizeof(char)); is not right since arr is of type char** . You should use sizeof(char*) or better (sizeof(*arr)) since sizeof(char) is usually not equal to sizeof(char*) for modern systems.

2. You don't have braces {} around your else statement in ft_split_whitespaces which you probably intended. So your conditional logic breaks.

3. You are allocating a new char[] for every non--whitespace character in the while loop. You should only allocate one for every new word and then just fill in the characters in that array.

4. *(arr+index2) = &str[index]; This doesn't do what you think it does. It just points the string at *(arr+index2) to str offset by index . You either need to copy each character individually or do a memcpy() (which you probably can't use in the question). This explains why your answer just provides offsets into the main string and not the actual tokens.

5. **arr = '\\0'; You will lose whatever you store in the 0th index of arr . You need to individually append a \\0 to each string in arr .

6. *(arr+index2) = (char*) malloc(index * sizeof(char)); You will end up allocating progressively increasing size of char arrays at because you are using index for the count of characters, which keeps on increasing. You need to figure out the correct length of each token in the string and allocate appropriately.

Also why *(arr + index2) ? Why not use the much easier to read arr[index2] ?

---

Further clarifications:

Consider str = "abc de"

You'll start with

*(arr + 0) = (char*) malloc(0 * sizeof(char));
//ptr from malloc(0) shouldn't be dereferenced and is mostly pointless (no pun), probably NULL
*(arr + 0) = &str[0]; 

Here str[0] = 'a' and is a location somehwhere in memory, so on doing &str[0] , you'll store that address in *(arr + 0)

Now in the next iteration, you'll have

*(arr + 0) = (char*) malloc(1 * sizeof(char)); 
*(arr + 0) = &str[1]; 

This time you replace the earlier malloc'd array at the same index2 again with a different address. In the next iterations *(arr + 0) = (char*) malloc(2 * sizeof(char)); . You end up resetting the same *(arr + index2) position till you encounter a whitespace after which you do the same thing again for the next word. So don't allocate arrays for every index value but only if and when required. Also, this shows that you'll keep on increasing the size passed to malloc with the increasing value of index which is what #6 indicated.

Coming to &str[index] .

You are setting (arr + index2) ie a char* (pointer to char ) to another char* . In C, setting a pointer to another pointer doesn't copy the contents of the second pointer to the first, but only makes both of them point to the same memory location. So when you set something like *(arr + 1) = &str[4] , it's just a pointer into the original string at index = 4 . If you try to print this *(arr + 1) you'll just get a substring from index = 4 to the end of the string, not the word you're trying to obtain.

**arr = '\\0' is just dereferencing the pointer at *arr and setting its value to \\0 . So imagine if you had *(arr + 0) = "hello\\0" , you'll set it to "\\0ello\\0" . If you're ever iterating over this string, you'll never end up traversing beyond the first '\\0' character. Hence you lose whatever *arr was earlier pointing to.

Also, *(arr + i) and arr[i] are exactly equivalent and make for much better readability. It better conveys that arr is an array and arr[i] is dereferencing the i th element.

Answer 2

Here is how I would do it:

#include <stdio.h>  // printf
#include <stdlib.h> // malloc

// this returns an array of pointers to strings
// that is one longer than the number of strings
// the last item in the array is always NULL
// so that the caller can tell when they get to the end
// we have to do this because we have no way
// to return the size of the finished array
char **ft_split_whitespaces(char *str)
{
    /*
     * First count the number of pieces in the string
     */

    // there will always be a NULL at the end of the array
    int size = 1;

    // if the string isn't empty there is one piece after the last space
    if (*str != '\0')
        size++;
        
    // there will be one piece for the bit before each space
    // so loop through the string looking for a space
    for (char *pointer = str; *pointer != '\0'; pointer++)
        if (*pointer == ' ')
            size++;

    /*
     * Now allocate the array of items that will be returned
     */
     
    char **array = malloc(size * sizeof(char*));
    if (array == NULL) return NULL; // ERROR: return "Something really bad happened!"

    /*
     * Then split the string into items and store them into the array
     */

    // index is where the piece will be stored
    int index=0;

    // we need two pointers:
    // - one for where we currently are
    // - and one for what we are looking for
    char *current=str, *next=str;

    // we are done if we are at the end of the string    
    while (*current != '\0')
    {
        // find a space character
        // but stop looking if we find the end of the string instead
        while (*next!='\0' && *next!=' ')
            next++;
        
        // now allocate enough space for this piece
        char *piece = malloc(next - current + 1);
        if (piece == NULL) break; // ERROR: exit the loop and return array as it is
        
        // and copy the piece into the memory
        for (int i=0; i<next-current; i++)
            piece[i] = current[i];
        
        // then terminate the string
        piece[next-current] = '\0';
        
        // store the new piece and increase the index
        array[index++] = piece;
        
        // now we are done with that piece
        // so start looking for the enxt one
        current = ++next;
    }

    // make sure the array ends with a NULL;
    array[index] = NULL;
    
    // return the new array
    return array;
}

int main()
{
    char **items = ft_split_whitespaces("Hello World This Is Me");

    if (items == NULL)
        printf("Something really bad happened!");
    else // loop through the array until we find a NULL
        for (char **pointer = items; *pointer != NULL; pointer++)
            printf("%s\n", *pointer);

    return 0;
}

Try it at https://onlinegdb.com/MhXIUQdo0