How to overwrite part of a string in C? - c

Question

I have for instance a string. And I only want to change the beginning few characters of the string and leave the rest as they are. What is the best way to do this in C?
#include <stdio.h>
#include <string.h>
int main() {
char src[40];
char src2[40];
char dest[12];
memset(dest, '\0', sizeof(dest));
strcpy(src, "This is a string");
strcpy(src2, "That");
strncpy(dest, src, sizeof(src));
strncpy(dest, src2, sizeof(src2));
printf("Final copied string : %s\n", dest);
}
I would like the string to be changed from "This is a string" to "That is a string".
Is there an easy way to accomplish this that I am missing?

Answer 1

There are a few issues here.
First, dest is only 12 bytes long, which is too short to hold "This is a string". Trying to copy that string into dest will overrun the buffer. This invokes undefined behavior. Make it at least 20 bytes.
Second sizeof(src) gives you the size of the whole array, which is 40, not the length of the string. This will also give undefined behavior if the destination buffer is not big enough. Use strlen instead. The same goes for sizeof(src2).
With those changes, you should have this:
#include <stdio.h>
#include <string.h>
int main() {
char src[40];
char src2[40];
char dest[20];
memset(dest, '\0', sizeof(dest));
strcpy(src, "This is a string");
strcpy(src2, "That");
strncpy(dest, src, strlen(src));
strncpy(dest, src2, strlen(src2));
printf("Final copied string : %s\n", dest);
}

Answer 2

sizeof(src2) is 40 (it's the size of the entire array) - you probably meant strlen(src2) (which is just the amount of characters used for the string) :
strncpy(dest, src2, strlen(src2));
Note btw that your code has a buffer overrun issue : The dest array is not big enough to hold the resulting string. It needs to be at least 17 characters large to accomodate the "This is a string" string. You'll also want to use :
strncpy(dest, src, strlen(src));

Answer 3

I am confused and a little concerned about the memset() call. The memset call allows the use of strncpy() without worrying about the terminating '\0'. Such a call assumes that this logic will be used in a general purpose function that will be called from a higher level function.
If that is not the case, then the first strncpy() should be replaced with a strcpy and the memset should be abandoned:
#include <stdio.h>
#include <string.h>
int main() {
char src[40];
char src2[40];
char dest[20];
/* memset(dest, '\0', sizeof(dest)); -- No need for this */
strcpy(src, "This is a string");
strcpy(src2, "That");
strcpy(dest, src, strlen(src)); /* strcpy will put a '\0' at the end */
strncpy(dest, src2, strlen(src2));
printf("Final copied string : %s\n", dest);
}
However, if this will be called from a higher level function, then we really need to check for the lengths of the incoming strings and/or malloc the dest buffer and free it. The memset() is the elephant in the room that suggests that there is more logic to come which should be considered. Otherwise, just replace the first strncpy() with a strcpy().

Answer 4

Expanding on the answer by #dbush:
I think the code is still quite fragile.
#include <stdio.h>
#include <string.h>
int main() {
char src[40];
char src2[40];
char dest[20];
Here the first pitfall is created: dest is smaller than both sources. While that can be handled, it requires much more diligence in the subsequent code. It would be better to make the destination always large enough to hold the source(s).
memset(dest, '\0', sizeof(dest)); //Good
But it is also a good idea to initialize the other arrays with 0 as well.
memset(src, '\0', sizeof(src));
memset(src2, '\0', sizeof(src2));
Side note: Of course you could save the trouble of memset by just using the array initialization syntax:
char src[40] = {0};
char src2[40] = {0};
char dest[20] = {0};
The two next lines are potentially dangerous, provided that IRL the two strings might not be string constants. (And even then!) No length checking is provided... Better:
// strcpy(src, "This is a string");
// strcpy(src2, "That");
strncpy(src, "This is a string", sizeof(src)- 1);
strncpy(src2, "That", sizeof(src2) -1);
That way we make sure we don't cause any overflow.
We also make sure that the strings in src and src2 are properly null-terminated.
Now, the copying of src/src2 to dest is also dangerous. We must ensure not to overflow dest.
//strncpy(dest, src, strlen(src));
//strncpy(dest, src2, strlen(src2));
Better:
strncpy(dest, src, sizeof(dest) - 1);
strncpy(dest, "That is a long rubbish string that easily could overflow dest", sizeof(dest) -1);
We only copy as much as dest can hold and preserve the null terminator.
Now to the replacement of the first X characters. Again, we must make sure no overflow occurs. We use strlen to determine the actual size of the null-terminated string in src2, but need to use/evaluate the maximum size of dest. Therefore the mixture of strlen and sizeof.
memcpy just for the fun of it. You could use strncpy just as well.
memcpy(dest, src2, strlen(src2) < sizeof(dest) ? strlen(src2) : sizeof(dest));
printf("Final copied string : %s\n", dest);
}
So the whole, secure implementation looks like this:
#include <stdio.h>
#include <string.h>
int main() {
char src[40] = {0};
char src2[40] = {0};
char dest[20] = {0};
strncpy(src, "This is a string", sizeof(src)- 1);
strncpy(src2, "That is a long rubbish string and sooooooooooooooooooooooooo much more", sizeof(src2) -1);
strncpy(dest, src, sizeof(dest) - 1);
memcpy(dest, src2, strlen(src2) < sizeof(dest) ? strlen(src2) : sizeof(dest));
printf("Final copied string : %s\n", dest);
}
Please note that the use of sizeof is only seemingly equivalent to strlen; on char types that works, on other types you need to do more.