Thread: const char* to char array.

You need to use strcpy() - C and C++ do not allow assignment into whole arrays.

--
Mats

Is there a reason you need it inside a char array, buffer, specifically?

Originally Posted by cpjust

To be safer (and avoid possible buffer overflows) you should use strncpy()

Code:

strncpy( str, All.c_str(), sizeof( str ) );

. . . and whenever you use strncpy(), you have to add the NULL terminator yourself, in case the string was longer than (or the same length as) the buffer.

Code:

strncpy( str, All.c_str(), sizeof( str ) );
str[sizeof(str) - 1] = 0;

No, no. You see, strncpy() copies as many characters as it can from the source, including the NULL terminator, up to the maximum that you specify. However, if you try something like this

Code:

const char *source = "something";
char dest[4];

strncpy(dest, source, sizeof dest);

then dest will contain "some", without a NULL terminator. If you want to create a NULL-terminated string with strncpy(), you need to set the last character to a NULL terminator in case of this.

Code:

const char *source = "something";
char dest[4];

strncpy(dest, source, sizeof dest);
dest[sizeof dest - 1] = '\0';

Now dest contains "som\0", as you would expect.

Umm . . . no.

Code:

$ cat strncpy.c
#include <stdio.h>
#include <string.h>

int main() {
    const char *src = "something";
    char dest[4];
    size_t x;

    strncpy(dest, src, 4);

    for(x = 0; x < sizeof dest; x ++) {
        printf("'&#37;c' [%d]\n", dest[x], dest[x]);
    }

    return 0;
}
$ gcc strncpy.c -o strncpy
$ ./strncpy
's' [115]
'o' [111]
'm' [109]
'e' [101]
$

Voilà. Non-NULL-terminated.

[edit] In your last example, the result may be "som\0", but that's only because you passed "sizeof space - 1". You're relying on space[3] to be '\0', which you haven't set it to. (Plus you misspelled "strncat". )

Thinking about it a bit, the most efficient way to do this would be like this.

Code:

char space[4];

space[sizeof space - 1] = 0;
strncpy(space, "something", sizeof space - 1);

That way the strncpy() never overwrites the last character. Or perhaps . . .

Code:

char space[4];
const char *source = "something";
size_t len;

len = strlen(source);
if(len >= sizeof space) {
    space[sizeof space - 1] = 0;
}

strncpy(space, source, sizeof space - 1);

[/edit]

We aren't communicating.

Code:

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

int main (void)
{
    char space [4];

    space[0] = '\0';
    strncat(space, "something", sizeof space - 1);

    puts(space);

    return 0;
}

Verily, the output is expected.

Actually, your new comments indicate a complete misunderstanding of strncat. strncat by definition appends at most n characters from s2 to s1, and a terminating zero. n in my example is computed to 3. So no, in fact, I am not relying on space[3] to be zero, I'm relying on space[0] to be zero, which is a fairly safe assumption to make in what I posted, and probably lots of well written code. If s2 is shorter than s1, there is no problem, either.

I don't usually say this but RTFM.

You're right, it's my fault. I guess I assumed, from your original post, that you weren't aware of strncpy()'s behaviour. I wasn't aware that strncat() behaved differently from strncpy(). That's crazy. (But then strncpy() is crazy in the first place . . . .)

My apologies.