Example for strncpy() - c

Question

If I would use the strncpy function for the strings cat and dog. I don't understand if the \0 character is counted in or not, so I would like to know if the end result will be catdo? or would it be something like cat\0do
strncpy("cat", "dog", 2);

Answer 1

You should not use the strncpy and strncat functions at all.
Their names start with str, but they do not really work with strings. In C, a string is defined as "a character sequence terminated by '\0'". These functions do not guarantee that the resulting character array is always null-terminated.
The better alternatives are strlcpy and strlcat, but these are not available everywhere.
Even better would be a separate string library in which determining the length of a string were a constant-time operation. But that gets distracting.

Answer 2

As torstenvl mentioned, "cat" and "dog" are string literals, so you're not using the function correctly here. The first parameter is the destination, the second parameter is the source, and the third parameter is the number of bytes to copy.
char *strncpy(char *restrict s1, const char *restrict s2, size_t n)
Source: The Open Group Base Specification - strncpy
To answer your specific question: yes; the null terminator is copied to the destination string. n bytes are written, and if your source string s2 is shorter than n bytes, NULL is filled in until n bytes are written.
In your question, it looks like you're trying to append the two strings. To do this in C, you need to first allocate a source string buffer, copy the first string over, then copy the second string, starting from the end of the second string. Depending on where you start the last step, you can end up with either "catdog\0" or "cat\0dog\0". This is another example of the quintessential "off by one" errors.
To start, you have to calculate the length of the two strings you want to append. You can do this using strlen, from string.h. strlen does not count the null-terminator as part of the length, so remember that to get the length of the final string, you'll have to do strlen(s1) + strlen(s2) + 1.
You can then copy the first string over as you normally would. An easy way to do the second copy is to do this:
char* s2start = finalString[strlen(s1) + 1];
You can then do strncpy(s2start, s2, [the size of s2]) and that way you know you're starting right on the s1 null terminator, avoiding the "cat\0dog" error.
Hope this helps, good luck.

Answer 3

When you write out a string like "cat" or "dog" in c, the arrays cannot be changed, if you try it will result in undefined behavior. You can only use these if a function expects const char * input, const is telling you that it cannot/will not be changed in the function. When you write "dog" the data in the character array will look something like this:
{'d','o','g','\0'}
Notice it is NUL terminated.
The function you are using:
char *strncpy(char *dest, const char *src, size_t n)
Copies src to dst with a maximum length of n you cannot copy into "cat" as mentioned above, you can see char *dest is not constant but const char * src is constant. So the source could be "cat" or "dog"
If you were to allocate space for the string you are allowed to modify it:
char cat_str[] = "cat";
now the character array cat_str is initialized to "cat" but we can alway change it, note its length will be 4 (one for each letter plus a NUL) because we did not specify the length. So be sure to not change anything past cat_str[3], you can index it by 0 to 3

Answer 4

There is a common misconception from some static analysis tools that strncpy is a safer version of strcpy. It's not, it has a differnt purpose. If we insist on using it to prevent buffer overflows, you need to be cognisent of the fact that for it's signature
char * strncpy ( char * destination, const char * source, size_t num );
No null-character is implicitly appended at the end of destination if source is longer than num. Thus, in this case, destination shall not be considered a null terminated C string (reading it as such would overflow).
So if you know that your source is a null terminated C string, then you can do the following:
#include <stdio.h>
#include <string.h>
int main()
{
const char* source = "dog";
char destination[4] = "cat";
printf("source is %s\n", source);
printf("destination is %s\n", destination);
/* the strlen+1 accounts for null termination on source */
/* but you need to be sure that source can fit into destination */
/* and still be null terminated - (that's on you the programmer) */
strncpy(destination, source, strlen(source) + 1);
printf("source is still %s\n", source);
printf("destination is now %s\n", destination);
return 0;
}