Thread: Str_replace function

Ive been creating my own extended string library one of the functions is a str_replace function.

Code:

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

char *str_replace(char *find, char *replacement, const char *string);

int main()
{
	char string[] = "Testing String Testing String String test string";
	char *newString = str_replace("Testing","test",string);
	char *newString2 = str_replace("string", "", newString);
	
	printf("String: \t\t%s\nNew String: \t\t%s\nNew String 2: \t\t%s\n", string, newString, newString2);
	
	free(newString);
	free(newString2);
	return 0;
}

char *str_replace(char *find, char *replacement, const char *string)
{
	char *ptr, *newString, *compString, *restOfString;
	int findLength = 0, position = 0, endPosition = 0;
	
	int i; /* for loop */
	
	/* String Lengths and Difference */
	findLength = strlen(find);
	
	/* Allocate Memory for compString */
	if ((compString = malloc(strlen(string) + 1))==NULL)
	{
		fprintf(stderr, "Memory Allocation Error");
		exit(1);
	}
	strcpy(compString,string);
	
	/* Allocate 1 char for null character for newString (used to return the new string */
	if ((newString = malloc(1))==NULL)
	{
		fprintf(stderr, "Memory Allocation Error");
		exit(1);
	}

	/* Find and Replace all Strings */
	while (compString != NULL) /* Set to Null incase we find a substring on the end of the string */
	{
		/* Find Substr */
		if ((ptr=strstr(compString, find))!=NULL)
			position=ptr-compString;
		else
		{
			/* Why ?
				Cos there is possibly more on the string we need to return the entire string with the find strings replaced
			*/
			if ((newString = realloc(newString, strlen(newString) + strlen(compString) + 1))==NULL)
			{
				fprintf(stderr, "Memory Allocation Error");
				exit(1);
			}
			
			/* Concatenate the end of the string */
			strcat(newString, compString);
			
			/* Free compString */
			free(compString);
			return newString; /* All Possible strings to be found have been we need to kill this loop */
		}
		
		if (position != 0)
		{
			if ((restOfString=malloc(position))==NULL)
			{
				fprintf(stderr, "Memory Allocation Error");
				exit(1);
			}
		
			/* Copy the String to restOfString before finding the substr */
			for (i=0;i<=position;i++)
				(restOfString)[i]=(compString)[i];
			(restOfString)[position]='\0';
			
			/* Allocate Memeory for restOfString for newString */
			if ((newString = realloc(newString, strlen(newString) + strlen(restOfString) + strlen(replacement) + 1))==NULL)
			{
				fprintf(stderr, "Memory Allocation Error");
				exit(1);
			}
			
			/* Concatenate restOfString onto newString */
			strcat(newString, restOfString);
			free(restOfString);
		}
		
		/* Reallocate Memory to newString */
		if ((newString = realloc(newString, strlen(newString) + strlen(replacement) + 1))==NULL)
		{
			fprintf(stderr, "Memory Allocation Error");
			exit(1);
		}
		/* Concatenate new String */
		strcat(newString, replacement);
		
		/* Delete from found onwards */
		endPosition = position + findLength;
		(compString) = (ptr+strlen(find));
	}
	
	free(compString);
	return newString;
}

The first use of this function on the same string works correctly, however use the same string and function again and I get a seg fault error. Now it could be that im freeing wrong things or something and I simply cannot find where it is.

Strange... I tried your program in my compiler (Dev-cpp 4.9.9.0) and I don't get any seg fault...

Ive seemed to have found it

Code:

            /* Free compString */
            free(compString);
            return newString; /* All Possible strings to be found have been we need to kill this loop */

However remove the free(compString); and the next time str_replace is used there are still garbage characters around.

Originally Posted by gsoft

Ive seemed to have found it


However remove the free(compString); and the next time str_replace is used there are still garbage characters around.

Here's a way to debug something like this:

Since you have more-or-less located an anomaly, see what you are malloc'ing and what you are free'ing:

Code:

    if ((compString = malloc(strlen(string) + 1))==NULL)
    {
        fprintf(stderr, "Memory Allocation Error");
        exit(1);
    }
    printf("After malloc(): compString = %p\n", compString);
    strcpy(compString,string);

and

Code:

            /* Free compString */
            printf("Before free(): compString = %p\n", compString);
            free(compString);

Hmmm. Time for a re-think? (Red flag when set a pointer to an allocated region and change the value before free.)

Regards,

Dave

Ive decided to redo the function and do Memory Allocation within the function. The new prototype is

Code:

char *replace_str(char *find, char *replacement, const char *string, char *destination, size_t size);

Now destination pointer will be allocated prior to being sent to the replace_str function.

e.g.
char test[100];

So 100 bytes have been allocated for test which will be sent as the destination parameter. Is it possible to then reallocate memory using realloc if the string becomes bigger than 100 bytes

Code:

if ((destination=realloc(destination, size + strlen(string) + 1))==NULL)
{
  //error here
}

Since im guessing destination since it hasnt be given a value and has garbage characters, its produces a segfault when using realloc.

This is what the str_replace function now replace_str funciton looks like now, its incomplete.

Code:

char *replace_str(char *find, char *replacement, const char *string, char *destination, size_t size)
{
	char *ptr, *tempString;
	int findLength = 0;
	
	/* Gather Find String Details */
	findLength = strlen(find);
	
	/* Allocate Memory for string and copy */
	if ((tempString = malloc(strlen(string) + 1))==NULL)
	{
		fprintf(stderr, "Memory Allocation Error");
		exit(1);
	}
	strcpy(tempString, string);
	
	return NULL;
}

Thanks.