Assert is failing in a string array comparison

Question

In this part of my code I remove white spaces of string1 and copy the result to string2.

char * remove_blank_spaces(char * string1) {
   char * string2 = malloc(sizeof(string1));
   int index = 0;

   for (int i = 0; string1[i] != 0; i++) {
      if(string1[i] != ' ') {
         //printf("i: %d\n", i);
         //printf("c2: %c\n", string1[i]);
         string2[index] = string1[i];
         index++;
      }
   }
   string2[index] = '\0';

   printf("string2: %s\n", string2);
   return string2;
}

I check the result with:

assert(remove_blank_spaces("a  b") == "ab");  // Edit: here is the error!

I got an error: Assertion failed! and Expression: remove_blank_spaces("a b") == "ab"

I compared the strings in Virtual-C and they look the same. Why the assertion is failing?

Answer 1

Your code has a bug: malloc allocates insufficient space, and this results in undefined behaviour when trying to access unallocated memory.

The assertion is also failing because you are comparing pointers via ==, instead of C strings via strcmp.

Furthermore, I suggest making two changes:

• Don’t mix computation and output. Return the value, don’t printf it inside the function.
• Use descriptive and correct names. This requires taking context into account. For instance, index can generally be a good name, but in your case it’s unclear which index you’re referring to, and this invites errors, where index is used to index into the wrong variable. As for “correct” names, what you call “blank space” is more conventionally known as “whitespace”.

To improve the second point, I suggest actually changing the implementation and, instead of having a second index variable, to iterate over the output using a pointer. There are other possibilities, but this one has the advantage that accidentally indexing using the wrong variable is impossible.

Taking this together, we get

char *remove_whitespace(const char *str) {
    char *result = malloc(strlen(str) + 1);
    char *out = result;

    for (size_t i = 0; str[i] != '\0'; i++) {
       if (str[i] != ' ') {
           *out++ = str[i];
       }
    }
    *out = '\0';
    return result;
}

We could additionally do away with the i loop counter. Unfortunately the result is less readable, not more, because we would need to increment str at the end of the loop, and this would leave us with an unsightly for (; *str != '\0'; str++) loop construct.

Answer 2

For starters this function declaration

char * remove_blank_spaces(char * string1) {

is incorrect and only confuses users of the function. If within the function you are creating a new character array then the parameter shall have the qualifier const.

char * remove_blank_spaces( const char * string1) {

Otherwise the function should change the original string "in-place".

This call

char * string2 = malloc(sizeof(string1));

also is incorrect. I think you mean

char * string2 = malloc( strlen( string1 ) + 1 );

But even this call is not very good because the result string can be much less than the original string.

So at first you should count the numb er of characters in the result string and only then allocate the memory.

This assert is also incorrect

assert(remove_blank_spaces("a  b") == "ab");

In this expression there are compared addresses of two string: the first one is the string returned by the function and the second one is the string literal.

Even if you will write an expression like this

assert( "ab" == "ab");

the value of the expression can be equal either to logical true or false depending on the compiler option that specifies whether equal string literals are stored as one string literal or occupy different extents of memory.

You should write instead

assert( strcmp( remove_blank_spaces("a  b"), "ab" ) == 0 );

Take into account that it is reasonable also to consider trhe tab character '\t' in the if statement like

if(string1[i] != ' ' && string1[i] != '\t') {

Or you could use the standard function isblank.

Here is a demonstrative program

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <string.h>

char * remove_blank_spaces( const char *s ) 
{
    size_t n = 0;

    for ( size_t i = 0; s[i] != '\0'; i++ )
    {
        if ( !isblank( ( unsigned char )s[i] ) ) ++n;
    }

    char *result = malloc( n + sizeof( ( char )'\0' ) );

    char *p = result;

    do
    {
        if ( !isblank( ( unsigned char )*s ) )
        {
            *p++ = *s;
        }
    } while ( *s++ != '\0' );

    return result;
}

int main(void) 
{
    const char *s1 = "a b";
    char *s2 = remove_blank_spaces( s1 );

    assert( strcmp( s1, s2 ) == 0 );

    puts( s2 );

    free( s2 );

    return 0;
}

The program output is

ab

Pay attention to that instead of the type int as it is shown in other answers you should use the type size_t for the variables index and i because it is the type that is used with string lengths and indices and by the function malloc. The type int is not large enough to store size of strings.

If you indeed want to declare the function like

char * remove_blank_spaces( char *s ) 

that is when the parameter does not have the qualifier const then you shall not allocate dynamically a new character array within the function and the function itself can look much simpler.

Here is a demonstrative program.

#include <stdio.h>
#include <assert.h>
#include <string.h>

char * remove_blank_spaces( char *s ) 
{
    char *destination = s;
    char *source = s;

    do
    {
        if ( *source != ' ' && *source != '\t' )
        {
            *destination++ = *source;
        }
    } while ( *source++ != '\0' );

    return s;
}

int main(void) 
{
    char s[] = "a b";

    remove_blank_spaces( s );

    assert( strcmp( s, "ab" ) == 0 );

    puts( s );

    return 0;
}

Its output is

ab