C - converting string (sentence) into strings list - c

Question

I need to copy a sentence, for example "Hello world" into a string list, meaning into a char array where every 2 words are seperated by a '\0'.
note that word is defined as any amount of characters in a row without a white spaces.
So whenever my program detects any amount of white spaces in a row (including only 1 white space) it should wtire a single '\0' instead.
the problem is that after writting '\0' for the first time in my target char array, I can't write to it anymore. I guess its because '\0' means end of string but in my case I'm trying to implement a string list inside char array so I must have '\0' between every 2 words.
Basically my question is how can I countinue writing to char array after putting '\0'?
Here is my code so far (as you can see I also check for enough space in traget at every iteration but that part works fine so isn't really intersting)
int strListFromWords(const char* source, char* target, int buffSize)
{
if (buffSize < 2) return -1;
char* sCurrentPointer = source;
char* tCurrentPointer = target;
int charsInTarget = 0;
while (*sCurrentPointer != '\0') // While not end of string
{
if (charsInTarget + 2 < buffSize) // if there is enough space in target for current char
{
charsInTarget++;
if (!isspace(*sCurrentPointer)) // if current char isn't space
{
*tCurrentPointer = *sCurrentPointer;
sCurrentPointer++;
tCurrentPointer++;
}
else
{
*tCurrentPointer = '\0'; // PROBLEMATIC LINE put '\0' instead of spcace (in target)
sCurrentPointer++; // goto next char in source
tCurrentPointer++; // goto next position in target
while (isspace(*sCurrentPointer)) // while there are more spaces in a row
{
sCurrentPointer++; // just skip them without messing with target
}
}
}
else
{ // Not enough space
emptyStrList(target);
return 0;
}
}
*tCurrentPointer = '\0';
*(tCurrentPointer + 1) = '\0';
return numStrsInList(target);
}
Thank you,

Answer 1

There is nothing to prevent you to write past 0.
I tested your function with the following snippet, and it returns word_count correctly. The target buffer will contain the 0 terminated words, plus an extra 0 at the end. I guess, that was the intention.
#include <conio.h> // for getch()
#include <malloc.h>
#include <string.h>
int main()
{
char* source = " Hello World!\nThis is line number two.\n\n \n \n This is the last line";
size_t buflen = strlen(source);
char* target = (char*)malloc(strlen(source));
int word_count = strListFromWords(source, target, buflen);
printTarget(target);
free(target);
getch();
}
This function will show you the whole target buffer:
void printTarget(const char* target) {
char prev = ' ';
for (int i = 0;; i++) {
if (target[i])
putch(target[i]);
else {
putch('\n');
if (!prev)
break;
}
prev = target[i];
}
}
Some minor changes were necessary, to make it compile:
#include <stdio.h>
#include <ctype.h>
int strListFromWords(const char* source, char* target, int buffSize)
{
if (buffSize < 2) return -1;
char* sCurrentPointer = (char*)source;
char* tCurrentPointer = target;
int charsInTarget = 0;
int numStrsInList = 0;
while (*sCurrentPointer != '\0') // While not end of string
{
if (charsInTarget + 2 < buffSize) // if there is enough space in target for current char
{
charsInTarget++;
if (!isspace(*sCurrentPointer)) // if current char isn't space
{
*tCurrentPointer = *sCurrentPointer;
sCurrentPointer++;
tCurrentPointer++;
}
else
{
*tCurrentPointer = '\0'; // PROBLEMATIC LINE put '\0' instead of spcace (in target)
numStrsInList++;
sCurrentPointer++; // goto next char in source
tCurrentPointer++; // goto next position in target
while (isspace(*sCurrentPointer)) // while there are more spaces in a row
{
sCurrentPointer++; // just skip them without messing with target
}
}
}
else
{ // Not enough space
//emptyStrList(target);
return 0;
}
}
*tCurrentPointer = 0;
*(tCurrentPointer + 1) = 0;
return numStrsInList;
}
Pls note, I addressed only what was asked.

Answer 2

I suppose the main problem lies in the formulation of the requirement.
If the requirement is "split a sentence into words", then the result should be an array of "words", meaning an array of strings. If this were the requirement, then the function should have a signature like char **getWordsArrayFromSentence(const char* sentence). As you come up with a different signature, I think that your requirement is something different.
The signature of your method is int strListFromWords(const char* source, char* target, int buffSize), which indicates that it is about copying from source to target while replacing every sequence of white spaces with a single delimiter.
If you chose, for example, character ; as delimiter, then the result for sentence "Hello world" should be "Hello;world"; You can print the result, e.g. with printf("%s", target), and can check whether your algorithm works fine.
However, if you chose string termination character '\0' as delimiter, then the result looks as if it only contained the first word (although the remainder of target will contain the other words as well): target would be "Hello\0world\0" with \0 standing for string termination character. When you then print out target with printf("%s", target), then the output is Hello, i.e. the content of target until the first string termination character.
Hence, signature int strListFromWords(const char* source, char* target, int buffSize) yields a single consolidated sequence of characters but not a "list" of words; the "words" are actually contained in target, but you do not have a data structure that lets you directly access each word at its beginning.
BTW: note that the following lines are problematic,
*tCurrentPointer = "\0";
*(tCurrentPointer + 1) = "\0";
because you assign to *tCurrentPointer, which is a character within target, a pointer value, i.e. the pointer to string "\0"; Instead, you should write
*tCurrentPointer = '\0';
*(tCurrentPointer + 1) = '\0';
(Note the single quotes).

Answer 3

You were not very far. Ok there are still some problems to fix:
int strListFromWords(const char* source, char* target, int buffSize)
{
if (buffSize < 2) return -1;
//char* sCurrentPointer = source; lose const qualifier
const char* sCurrentPointer = source; // better!
or even better:
int strListFromWords(const char* sCurrentPointer, char* target, int buffSize)
{
if (buffSize < 2) return -1;
char* tCurrentPointer = target;
and mainly:
/* *tCurrentPointer = "\0";
*(tCurrentPointer + 1) = "\0"; NO! "\0" is a char ARRAY */
*tCurrentPointer = '\0';
*(tCurrentPointer + 1) = '\0';
But apart from that you code does what it is expected to... The terminating '\0' does not lock the array. It just mark an end of string that will be used but all string functions, but provided you are still inside the array you can write past the '\0'.
You can control it with that code:
int numStrsInList(char *target) {
int n = 0;
while (*target) {
target += strlen(target) + 1; // skip past the '\0'
n += 1;
}
return n;
}
int strListFromWords(const char* source, char* target, int buffSize)
...
int main() {
char target[32];
char src[] = "Hello to the world";
int n;
char *ix = target;
n = strListFromWords(src, target, sizeof(target));
printf("%d words:", n);
while (*ix) {
printf(" >%s<", ix);
ix += strlen(ix) + 1;
}
putchar('\n');
return 0;
}
This outputs as expected:
4 words: >Hello< >to< >the< >world<

Answer 4

*tCurrentPointer = "\0";
*tCurrentPointer has type char; you cannot assign an array (or a pointer after the automatic conversion) to a char.
I suggest you turn on all your compiler warnings and heed them.