Segmentation Fault from Split String Function - c

Question

I am required to write a function that splits a string into individual words.
My first parameter is a string. We assume that the words in the string are separated by single spaces, with no spaces before the first word or after the second word. Punctuation like spaces for example is part of a word. My second parameter is an address of an integer in which the function gives it the value of the number of words in the string. The return value is a pointer that points of an array of strings containing the individual words in the sentence. I need to allocate it memory from the heap and have one word in each index of the array. The strings are copies of the original words, not pointers. Here is my code :
char** splitString(char theString[], int *arraySize) {
*arraySize = countSpaces(theString) + 1; //Points to the number of words in the string.
char** pointerToArrayOfStrings = malloc(*arraySize * sizeof(char *)); //Allocated memory for '*arraySize' character pointers
int characters = 0;
for (int i = 0; i < *arraySize; i++) {
while (theString[characters] != ' ' || theString[characters] != '\0') {
characters++;
}
characters++;
pointerToArrayOfStrings[i] = (char *)malloc(characters);
pointerToArrayOfStrings[i][characters] = '\0';
}
for (int word = 0; word < *arraySize; word++) {
int ch = 0;
while (ch < strlen(pointerToArrayOfStrings[word])) {
pointerToArrayOfStrings[word][ch] = theString[ch];
}
ch+=2;
}
return pointerToArrayOfStrings;
}
This is immediately giving me segmentation faults. I am very new to pointers, so my method is to first allocate the array with the amount of memory for "numberOfWords" character pointers. Then I allocated each character pointer with the size of the corresponding word. After, I filled the slots with the characters from the original string. I don't know what I'm missing.

Answer 1

The comments have already addressed your questions about seg-faults etc. But since you did not say it was required how you split the string, I wanted to suggest looking at another approach.
Consider these steps:
1) Walk through string counting occurrences of white space (words) and track longest word found.
2) Knowing count, and longest word, you have what you need to allocate memory. Do it.
3) In a for loop, use strtok() with the delimiters of: , \n, \t etc. to tokenize the string.
4) Using strcpy() (also in the loop) to transfer each token into the string array.
5) Return array. Use array. Free all allocated memory.
Example code to do these steps:
char** splitString(const char theString[], int *arraySize);
char ** create_str_array(int strings, int longest) ;
int main(void)
{
int size;
char ** string = splitString("here is a string", &size);
return 0;
}
char** splitString(const char theString[], int *arraySize)
{
*arraySize = strlen(theString) + 1; //Points to the number of words in the string.
char *tok;
char *dup = strdup(theString);//create copy of const char argument
char** pointerToArrayOfStrings = NULL;
int characters = 0;
int len = 0, lenKeep = 0, wordCount = 0, i;
/// get count of words and longsest string
for(i=0;i<*arraySize;i++)
{
if((!isspace(theString[i]) && (theString[i])))
{
len++;
if(lenKeep < len)
{
lenKeep = len;
}
}
else
{
wordCount++;
len = 0;
}
}
/// create memory. (array of strings to hold sub-strings)
pointerToArrayOfStrings = create_str_array(wordCount, lenKeep);
if(pointerToArrayOfStrings)// only if memory creation successful, continue
{
/// parse original string into sub-strings
i = 0;
tok = strtok(dup, " \n\t");
if(tok)
{
strcpy(pointerToArrayOfStrings[i], tok);
tok = strtok(NULL, " \n\t");
while(tok)
{
i++;
strcpy(pointerToArrayOfStrings[i], tok);
tok = strtok(NULL, " \n\t");
}
}
}
/// return array of strings
return pointerToArrayOfStrings;
}
char ** create_str_array(int strings, int longest)
{
int i;
char ** a = calloc(strings, sizeof(char *));
for(i=0;i<strings;i++)
{
a[i] = calloc(longest+1, 1);
}
return a;
}