String concatenation in c - c

Question

I have a variable called char *inputstr, if the string length given to variable is a an odd number, I need to insert a "0" at the beginning of the string variable inputstr.
For example:
char *inputstr = "1ABc2" .
Now I need to append "0" and make it "01ABc2". How do I achieve this?
char a[2] = "0";
char *inputstr = "1ABc2";
if( strlen (inputstr) % 2 == 0)
{
strcat (a, inputstr);
strcpy (inputstr, a);
}
if( condition)
{
Using inputstr variable // here string value is along with junk characters
}

Answer 1

First, you need to set aside a buffer large enough for your target string:
/**
* Attempting to modify the contents of a string literal leads to undefined
* behavior; to be safe, pointers to literals should be declared "const".
* You are not going to write the modified string back to what inputstr
* points to.
*/
const char *inputstr = "1ABc2";
/**
* Compute the size of the target buffer, which is the length of inputstr
* plus 1 for the leading "0" plus 1 for the string terminator.
*/
size_t targetBufferLength = strlen( inputstr ) + 2;
/**
* Allocate the target buffer. Since targetBufferLength is a run-time
* value, this will only work with C99 and later. If you're using C90
* or earlier, targetBufferLength will have to be a compile-time constant,
* so you'll have to compute it manually and declare it as
*
* char targetBuffer[7]; // 5 + 1 + 1
*
* or
*
* #define TARGETBUFFERLENGTH 7
* ...
* char targetBuffer[TARGETBUFFERLENGTH];
*
*/
char target[targetBufferLength] = {0};
Now you can write your new string to the target buffer. You can use sprintf:
sprintf( target, "%s%s", "0", inputstr );
or you can use a combination of strcpy and strcat (or strncpy and strncat for the paranoid in the room):
strcpy( target, "0" );
strcat( target, inputstr );
Be aware of the potential for buffer overflow with either method. Make sure that your target buffer is large enough for the final string. Using strcpy and strcat is risky, but using strncpy and strncat in their place isn't a guarantee of success either.
You could also allocate the buffer dynamically:
char *target = calloc( targetBufferLength, sizeof *target );
The advantage of this is that you can resize the buffer as necessary if it
isn't big enough:
if ( strlen( target ) + strlen( newStr ) > targetBufferLength )
{
char *tmp = realloc( target, (targetBufferLength + strlen( newStr ) + 1) * sizeof *target );
if ( tmp )
{
target = tmp;
targetBufferLength += strlen( newStr ) + 1;
strcat( target, newStr );
}
else
{
// could not extend target buffer, don't append
}
}
The disadvantage is that you now have memory management issues, and you have to remember to free the buffer when you're done with it.

Answer 2

you can use memmove as the areas overlap but IMO is better to write a simple routine for it:
src - the string to append in front of the dest. dest has to be big enough to accommodate its new characters
char *straddfront(char *dest, const char *src)
{
size_t srclen = strlen(src);
size_t destlen = strlen(dest);
for (int i = 0; i <= destlen; i++)
*(dest + destlen + srclen - i) = *(dest + destlen - i);
strncpy(dest, src, srclen);
return dest;
}

Answer 3

You are searching for strcat (or really better strncat) defined in string.h
But you have to notice:
strcat concatenates two strings, thus you need to use the string "0" as the destination
if destination is not large enough, program behavior is unpredictable
the destination (the first argument of strcat i the only one that is modified, not the second argument (that is actually a const char*)