How to zero-initialize a C string (array of wchar_t)?

[Niels Dekker - no reply address]

Are all the following initializations semantically equivalent?

wchar_t a[8] = {L'\0'};
wchar_t b[8] = {'\0'};
wchar_t c[8] = {0};
wchar_t d[8] = {};

If so, why don't we all use an empty initializer list, {}, when
zero-initializing a C-style string? I was wondering, because the book
C++ Coding Standards (Sutter & Alexandrescu) says at item 19, "Always
initialize variables":

char path[MAX_PATH] = { '\0' };
Niels Dekker
http://www.xs4all.nl/~nd/dekkerware

[Eric Boutin]

On Sat, 11 Dec 2004 15:47:16 +0100, Niels Dekker - no reply address
wrote*:

Are all the following initializations semantically equivalent?

wchar_t a[8] = {L'\0'};
wchar_t b[8] = {'\0'};
wchar_t c[8] = {0};
wchar_t d[8] = {};

If so, why don't we all use an empty initializer list, {}, when
zero-initializing a C-style string? I was wondering, because the book
C++ Coding Standards (Sutter & Alexandrescu) says at item 19, "Always
initialize variables":

char path[MAX_PATH] = { '\0' };

you need to fill the array with '\0' because if the array is of dimension
10 let's say, the last char is '\0' and you set the first 5 characters
to let's say 'hello'
you'll get :

0 1 2 3 4 5 6 7 8 9
h e l l o t d r a '\0'

because the 5-6-7-8 characters were not set and are still using unset
memory. Maybe your compiler will clear the memory for you but I'm not
shure it's a standard behavior and it's not a good habbit to take
however if you do
memset(path, '\0', 10);
//set path value here
you'll get

hello'\0'
whatever's the lenght of path
which is the wanted result

or even better !!
give a try to the STL

#include <string>
std::string path = "hello";
beside std::string is a lot more secure than char[] because it's size
will autoincrease as you append data.

A small performance hit but a more secure program...

beside;
cin >> path; //where path is std::string

is almost impossible to overflow... however
cin >> path; //where path is char[]

is really easy to overflow.. if you allocated 10 char and the user input
40 characters... your program may not recover


Hope it helped
========
Eric Boutin
er********@users.sourceforge.net

[Phlip]

Eric Boutin wrote:

Niels Dekker wrote :

Are all the following initializations semantically equivalent?

wchar_t a[8] = {L'\0'};
wchar_t b[8] = {'\0'};
wchar_t c[8] = {0};
wchar_t d[8] = {};

If so, why don't we all use an empty initializer list, {}, when
zero-initializing a C-style string? I was wondering, because the book
C++ Coding Standards (Sutter & Alexandrescu) says at item 19, "Always
initialize variables":

char path[MAX_PATH] = { '\0' };

you need to fill the array with '\0' because if the array is of dimension
10 let's say, the last char is '\0' and you set the first 5 characters
to let's say 'hello'
you'll get :

0 1 2 3 4 5 6 7 8 9
h e l l o t d r a '\0'

because the 5-6-7-8 characters were not set and are still using unset
memory. Maybe your compiler will clear the memory for you but I'm not
shure it's a standard behavior and it's not a good habbit to take
however if you do
memset(path, '\0', 10);

The expression

char yo[3][5][7] = { 0 };

zero-fills everything, relatively optimally. No character contains the
memory's previous contents.

Avoid memset() in C++ as a rule of thumb. There are various reasons why.

wchar_t d[8] = {};

I don't know about that, but typing the 0 won't kill you.
or even better !!
give a try to the STL

#include <string>
std::string path = "hello";

Yep. Learn to use C++ as a high-level language first, before worrying about
bits.

--
Phlip
http://industrialxp.org/community/bi...UserInterfaces

[Rob Williscroft]

Niels Dekker - no reply address wrote in news:41BB0874.F10CB104
@this.is.invalid in comp.lang.c++:

Are all the following initializations semantically equivalent?

wchar_t a[8] = {L'\0'};
wchar_t b[8] = {'\0'};
wchar_t c[8] = {0};
wchar_t d[8] = {};

If so, why don't we all use an empty initializer list, {}, when
Because we all don't know that using {} works, I do and I use it.

It may be that using {} doesn't or didn't work with some C and pre-standard
C++ compilers, but AIUI using { 0 } has allways worked, which is probably
why the advice is repeated.
zero-initializing a C-style string? I was wondering, because the book
C++ Coding Standards (Sutter & Alexandrescu) says at item 19, "Always
initialize variables":

char path[MAX_PATH] = { '\0' };

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Niels Dekker - no reply address]

Phlip wrote:

wchar_t d[8] = {};

I don't know about that, but typing the 0 won't kill you.

I'd rather not use an integer (0) when initializing a character. On the
other hand, using L'\0' is quite verbose. Actually I used to do:

wchar_t e[8] = L"";

But now I realize that this L"" literal might unnecessarely take up some
space (however small) while running my program.

An empty initializer list, {}, seems preferable, but apparently most C++
programmers aren't familiar with this notation. Except for Rob
Williscroft, luckily :-)
Eric Boutin wrote: give a try to the STL

#include <string>
std::string path = "hello";
In some cases, especially when you're depending on C-style libraries
(e.g., Windows API functions), using to C-style strings might be more
convenient.
Phlip wrote: Learn to use C++ as a high-level language first, before
worrying about bits.

Okay, but I like the bits too :-)
Regards,

Niels Dekker
http://www.xs4all.nl/~nd/dekkerware

[Andrey Tarasevich]

Niels Dekker - no reply address wrote:

Are all the following initializations semantically equivalent?

wchar_t a[8] = {L'\0'};
wchar_t b[8] = {'\0'};
wchar_t c[8] = {0};
wchar_t d[8] = {};
Yes.
If so, why don't we all use an empty initializer list, {}, when
zero-initializing a C-style string?
Most likely it is a C language inheritance. C language doesn't allow
'{}' initializer. Sometimes C-compatibility (of header files, for
example) might be important. Also not all compilers (and not all
programmers) "know" that '{}' initializer is allowed in C++ and continue
to enforce C specification for aggregate initializers.
I was wondering, because the book
C++ Coding Standards (Sutter & Alexandrescu) says at item 19, "Always
initialize variables":

char path[MAX_PATH] = { '\0' };

Maybe just to avoid confusing a reader, who's using a compiler that
doesn't accept '{}' initializer (MSVC++ 6, for example).

--
Best regards,
Andrey Tarasevich

[msalters]

Niels Dekker - no reply address wrote:

Phlip wrote:

wchar_t d[8] = {};
I don't know about that, but typing the 0 won't kill you.

I'd rather not use an integer (0) when initializing a character. On

the other hand, using L'\0' is quite verbose. Actually I used to do:

wchar_t e[8] = L"";

But now I realize that this L"" literal might unnecessarely take up some space (however small) while running my program.

So may any other expression with the same result. An optimizer may
replace any expression with a more efficient form, as long as both
forms meet the requirements laid out in the standard. E.g. a CPU
which has an register hardwired to zero (e.g. Itanium IIRC ) can
simply use a store instruction using that register as a source.
Regards,
Michiel Salters

[Niels Dekker - no reply address]

>> I used to do:

wchar_t e[8] = L"";

But now I realize that this L"" literal might unnecessarely take up
some space (however small) while running my program.

Michiel Salters replied: So may any other expression with the same result. An optimizer may
replace any expression with a more efficient form, as long as both
forms meet the requirements laid out in the standard.

So is there any difference (semantically, including their memory usage)
between the following initializations?

wchar_t a[8] = {L'\0'};
wchar_t e[8] = L"";
Kind regards,

Niels Dekker
http://www.xs4all.nl/~nd/dekkerware

[msalters]

Niels Dekker - no reply address wrote:

I used to do:

wchar_t e[8] = L"";

But now I realize that this L"" literal might unnecessarely take up some space (however small) while running my program.

Michiel Salters replied:

So may any other expression with the same result. An optimizer may
replace any expression with a more efficient form, as long as both
forms meet the requirements laid out in the standard.

So is there any difference (semantically, including their memory

usage) between the following initializations?

wchar_t a[8] = {L'\0'};
wchar_t e[8] = L"";

Notice the word "may" in my reply. That's not "must". That means
the answer here is "Perhaps". I don't know, it /will/ differ between
compilers and I don't know which version will be more efficient where.

Besides, your use of "memory usage" here and in earlier posts
covers concepts that are not included when the C++ standard talks
about "semantics".

Regards,
Michiel Salters

[Niels Dekker - no reply address]

>> So is there any difference (semantically, including their memory

usage) between the following initializations?

wchar_t a[8] = {L'\0'};
wchar_t e[8] = L"";

Michiel Salters replied: Notice the word "may" in my reply. That's not "must". That means
the answer here is "Perhaps". I don't know, it /will/ differ between
compilers and I don't know which version will be more efficient where.
I don't see how the initialization to {L'\0'} could reasonably be
implemented less efficiently than the initialization to L"". On the
other hand I can imagine an implementation that reserves memory for each
string literal it encounters, therefore having a less efficient
initialization to L"". Am I missing the point?

Besides, your use of "memory usage" here and in earlier posts
covers concepts that are not included when the C++ standard talks
about "semantics".

By "memory usage" I refer to the fact that string literals have static
storage duration.
Thanks so far,

Niels Dekker
http://www.xs4all.nl/~nd/dekkerware