Reverse string in malloc - c

Question

I need define a “word” in this question to be any sequence of characters that doesn’t contain a space or null character.
For example, the string “Hello World” would contain 2 words. However, it is actually possible for a word to be empty
i.e., zero chars.
A sentence would be a series of words that are separated by 1 space character. So “Hello World” would be a
sentence of two words. The goal of ReverseSentence would be to reverse the sentence in terms of word.
Right now, I am having an error whereby programs proceed to call function and prints out a1 to a5. Upon reaching a5, it seems that program abort and core dumped. If i replace blank with space, it will read in the previous input and replace according to number of space.
Where am i going wrong?
ReverseSentence.c
#include <stdlib.h> /* malloc */
#include <string.h> /* strcat, strcpy */
void ReverseSentence(char *str)
{
char *newSentence;
int i, j, start, len;
/* contains the string length of the input */
len = strlen(str);
/* position or index in the array */
start = strlen(str);
/* malloc */
newSentence = malloc(len + 1);
/* loop checks from the right of the sentences */
for (i = len; i >= 0; i--) {
/* if index reach the array with a space or zero */
if (str[i] == ' ' || i == 0) {
/* allocates memory */
char *word = malloc((start - i) + 1);
int c = 0;
if (i == 0)
/* index remains same */
j = i;
else
j = i + 1;
/* j smaller or equal than the start position */
for (; j <= start; j++) {
/*do a incremental*/
word[c++] = str[j];
}
/* hits a null char */
word[c] = '\0';
/* string concatenate */
strcat(newSentence, word);
/* if index hits a space */
if (str[i] == ' ')
strcat(newSentence, " "); /* concatenate space to newSentence */
else
strcat(newSentence, "\0");
start = i - 1;
/* free memory */
free(word);
}
}
newSentence[len] = '\0';
/* string copy */
/* str is destination, newSentence is the source */
/* copy new string to original string */
strcpy(str, newSentence);
/* free memory */
free(newSentence);
}
main.c
#include <stdio.h>
#include "ReverseSentence.h"
int main()
{
char a1[] = "Hello World ";
char a2[] = "abcdefghi ";
char a3[] = " ";
char a4[] = "C programming is a dangerous activity";
char a5[] = "a "; /* a sentence with only empty words */
ReverseSentence(a1);
printf("Test case 1:\"%s\"\n", a1); /* prints "World Hello" */
ReverseSentence(a2);
printf("Test case 2:\"%s\"\n", a2); /* prints "abcdefghi" */
ReverseSentence(a3);
printf("Test case 3:\"%s\"\n", a3); /* prints "" */
ReverseSentence(a4);
printf("Test case 4:\"%s\"\n", a4); /* prints "activity dangerous a is pro Cgramming" */
ReverseSentence(a5);
printf("Test case 5:\"%s\"\n", a5); /* prints " " */
return 0;
}
EDIT: new version
void ReverseSentence(char *str)
{
/* holder */
/* pointer to char */
char *newSentence;
int i, start, len, lastindex, size;
/* contains the string length of the input */
len = strlen(str);
lastindex = strlen(str);
/* starting position */
start = 0;
i = 0;
/* malloc */
newSentence = malloc(sizeof(char) * strlen(str));
while (i >= 0) {
for (i = len - 1; str[i] != '\0' && str[i] != ' '; i--) {
lastindex--;
}
/* number of chars in string size */
size = len - lastindex;
/* Copy word into newStr at startMarker */
strncpy(&newSentence[start], &str[lastindex], size);
/* pointer move to right */
start = start + size;
/* Space placed into memory slot */
newSentence[start] = ' ';
/* start position moves by 1 towards the right */
start = start + 1;
/* pointer at len moves to left */
lastindex = lastindex - 1;
/* lastindex moves to where len is */
len = lastindex;
}
/* Copy new string into old string */
for (i = 0; str[i] != '\0'; i++) {
str[i] = newSentence[i];
}
/* free memory */
free(newSentence);
}

Answer 1

In addition to Matthias' answer: you don't allocate enough memory, I just did a wild guess and added 1 to the arguments passed to malloc.
newSentence = malloc(len + 2); // +2 instead of +1
and
char *word = malloc((start - i) + 2); // +2 instead of +1
And now it doesn't crash anymore. So there is definitely a buffer overflow here.
I don't pretend the program is perfectly correct now. You should have a look into this.

Answer 2

Your code is not safe. You never initialize newSentence, since malloc() only allocates but not initialize the memory (in contrast to calloc()). Thus, you are starting with a garbage sentence, where you append something new (strcat()). Depending on the garbage, there may be no 0 even in the allocated memory, and you access some unallocated memory area.

Answer 3

Your method is too complicated. It has several issues:
you do not initialize newSentence: since malloc memory is uninitialized, you invoke undefined behavior when you copy the words at its end with strcat. You can fix that with *newSentence = '\0';
when you copy the word into the allocated word buffer, you iterate upto and including start, then you add a '\0' at the end. You effectively write one byte too many for the last word (case i == 0). This invokes undefined behavior.
strcat(newSentence, "\0"); does nothing.
allocating a buffer for each word found is wasteful, you could just copy the word with memcpy or with a simple for loop.
You could simplify with the following steps:
allocate a buffer and copy the string to it.
for each word in the string, copy it at the end of the destination and copy the separator before it if not at the end.
free the buffer.
Here is the code:
char *ReverseSentence(char *str) {
int len = strlen(tmp); /* length of the string */
char *tmp = strdup(str); /* copy of the string */
int i; /* index into the copy */
int j = len; /* index into the string */
int n; /* length of a word */
for (i = 0; i < len; ) {
n = strcspn(tmp + i, " "); /* n is the length of the word */
j -= n; /* adjust destination offset */
memcpy(str + j, tmp + i, n); /* copy the word */
i += n; /* skip the word */
if (tmp[i] != '\0') { /* unless we are at the end */
j--;
str[j] = tmp[i]; /* copy the separator */
i++;
}
}
free(tmp); /* free the copy */
return str;
}

Answer 4

There are at least two issues in the new version of your program:
You don't allocate enough memory, you don't account for the zero terminator. You should allocate one more byte.
in your first for loop you allow i to become -1. The loop should stop when i is zero: modify your for statement like this: for(i=len-1; tr[i] != ' ' && i >= 0; i--). You incorrecty assume that the first byte before the str buffer is zero, therefore the str[i]!='\0' is wrong. BTW accessing one byte before the str buffer yields in undefined behaviour.
There are probably other issues.