memset question

[Alch3mist]

just a quick lil question on memset()
if i do something like this

char buf[128];

memset(buf, 'A', sizeof(buf));

will this overwrite the terminating character \0? since im filling the whole buffer
with A or does memset automatically take into account the \0?
because i kno that \0, \r, and \n only take "1 slot" in the buffer

[VladimirF]

will this overwrite the terminating character \0?

There never was a terminating 0 in your buffer.

since im filling the whole buffer with A or does memset automatically take into account the \0?

Yes, you are filling the whole thing with 'A'; No, memset doesn't take \0 into account

[Alch3mist]

ight so would this work better
char buf[128] = 0;

memset(buf, 'A', sizeof(buf)-1);

or do i have to specify each time after lets say memset, memcpy, strcpy,strcat to place a \0 at the end of my buffer

[Paul McKenzie]

ight so would this work better
char buf[128] = 0;

Unless buf is declared as having 129 elements, that is a memory access violation.

Regards,

Paul McKenzie

[AvDav]

I guess, he meant
char buf[128] = {'\0'};
which will be ok.

[JohnyDog]

will this overwrite the terminating character \0? since im filling the whole buffer with A or does memset automatically take into account the \0?
because i kno that \0, \r, and \n only take "1 slot" in the buffer

Only subset of standard C function (str* functions, formating funcitons as printf/scanf, fgets/fputs etc.) knows or cares about null-terminated 'strings' - for every other function (including memset) it is just array of chars, with \0 having no special meaning. So, when you want to set null-terminated string with memset, you have to add the terminating null yourself. Also keep in mind that you need space for the terminating null, so for 128-char string, you need array of size for 129 chars. It's mess, i know - if you have chance to use C++ and std::string, go for it

[JMS]

right so would this work better

char buf[128] = 0;
memset(buf, 'A', sizeof(buf));

no that won't work cause of coarse your putting your null terminator in the first character of your array... Then you're overwriting that character with the memset... Try this..

char buf[128];

memset( buff, '\0', sizeof(buff));
memset( buff, 'A', sizeof( buff) -1 );

or you could do this..

char buff[128];

memset( buff, 'A', sizeof( buff ) -1 );
buff[ sizeof(buff)-1 ] = '\0';

[/code]

[JMS]

Unless buf is declared as having 129 elements, that is a memory access violation.

Regards,

Paul McKenzie

Paul check that... when you initialize an array like that it always begins from the beginning....

you must not have realized it was initializing from the variable declaration..


thus

char buff[128] = 0;                          // is fine... possible casting issue
char buff[128]  = "yada yad yada";  // is fine
char buff[128] = '\0';                        // is also fine

[spoon!]

char buff[128] = 0;
char buff[128] = '\0';

no, these are not valid initializers for an array

[eero_p]

char buff[128] = 0;
char buff[128] = '\0';

no, these are not valid initializers for an array

That's correct. They only set the value in pos. 128 to 0, not the whole array. As it was stated before, you need brackets to set the array to 0 when declaring it.

[dcjr84]

I think the solution from JMS is probably the best

char buff[128];

memset( buff, 'A', sizeof( buff ) -1 );
buff[ sizeof(buff)-1 ] = '\0';

Also, call me crazy, but I recall when initializing arrays, you need to use the initializer list

char buff[128] = {'\0'};

So I don't think either of these are correct for initializing an array

char buff[128] = 0;
OR
char buff[128] = '\0'

[screetch]

Unless buf is declared as having 129 elements, that is a memory access violation.

Regards,

Paul McKenzie

compiler won't compile this or have an extension which allows defining that way, in this case it is treated exactly as

char buf[128] = { 0 };

it will never be an access violation but it is for sure not standard. I believe only very few, obscure compilers implement this.

[namezero111111]

I'm pretty sure that what Paul meant was

buff[128] = 0;

would cause an access violation.
Otherwise you are right, JMS.


-Andy