What is the difference between using (char)0
and '\0'
to denote the terminating null character in a character array?
相关问题
- Multiple sockets for clients to connect to
- What is the best way to do a search in a large fil
- glDrawElements only draws half a quad
- Index of single bit in long integer (in C) [duplic
- Equivalent of std::pair in C
The backslash notation in a character literal allows you to specify the numeric value of a character instead of using the character itself. So
'\1'
[*] means "the character whose numeric value is 1",'\2'
means "the character whose numeric value is 2", etc. Almost. Due to a quirk of C, character literals actually have typeint
, and indeedint
is used to handle characters in other contexts too, such as the return value offgetc
. So'\1'
means "the numeric value as an int, of the character whose numeric value is 1", and so on.Since characters are numeric values in C, "the character whose numeric value is 1" actually is
(char)1
, and the extra decoration in'\1'
has no effect on the compiler -'\1'
has the same type and value as1
in C. So the backslash notation is more needed in string literals than it is in character literals, for inserting non-printable characters that don't have their own escape code.Personally, I prefer to write
0
when I mean 0, and let implicit conversions do their thing. Some people find that very difficult to understand. When working with those people, it's helpful to write'\0'
when you mean a character with value 0, that is to say in cases where you expect your0
is soon going to implicitly convert tochar
type. Similarly, it can help to writeNULL
when you mean a null pointer constant,0.0
when you mean a double with value 0, and so on.Whether it makes any difference to the compiler, and whether it needs a cast, depends on context. Since
'\0'
has exactly the same type and value as0
, it needs to be cast tochar
in exactly the same circumstances. So'\0'
and(char)0
differ in type, for exactly equivalent expressions you can either consider(char)'\0'
vs(char)0
, or'\0'
vs0
.NULL
has implementation-defined type -- sometimes it needs to be cast to a pointer type, since it may have integer type.0.0
has typedouble
, so is certainly different from0
. Still,float f = 1.0;
is identical tofloat f = 1;
andfloat f = 1.0f
, whereas1.0 / i
, wherei
is an int, usually has a different value from1 / i
.So, any general rule whether to use
'\0'
or0
is purely for the convenience of readers of your code - it's all the same to the compiler. Pick whichever you (and your colleagues) prefer the look of, or perhaps define a macroASCII_NUL
.[*] or
'\01'
- since the backslash introduces an octal number, not decimal, it's sometimes wise to make this a bit more obvious by ensuring it starts with a 0. Makes no difference for 0, 1, 2 of course. I say "sometimes", because backslash can only be followed by 3 octal digits, so you can't write\0101
instead of\101
, to remind the reader that it's an octal value. It's all quite awkward, and leads to even more decoration:\x41
for a capital A, and you could therefore write'\x0'
for 0 if you want.Character array means You are taking String so I advise you to use
'\0'
at the end of character Array after reading all the Characters of from user because0
is simple Character but'\0'
isNULL
which indicates end of String.They're both a 0, but
(char) 0
is a char, while'\0'
is (unintuitively) anint
. This type difference should not usually affect your program if the value is 0.I prefer
'\0'
, since that is the constant intended for that.Zero can mean a lot of different things in C. You should use the null character '\0', because then there can be no confusion over that your intention is string termination.
If you set a char to 0, that can mean null termination, but it can also mean that you are just using the char as an 8-bit integer for calculations, rather than as part of a string. This can be confused further if you are also using pointers in the same code and compare them against zero, which is then a null pointer.