In C, there appear to be differences between various values of zero -- NULL, NUL and 0.
I know that the ASCII character '0' evaluates to 48 or 0x30.
The NULL pointer is usually defined as:
#define NULL 0
Or
#define NULL (void *)0
In addition, there is the NUL character '\0' which seems to evaluate to 0 as well.
Are there times when these three values can not be equal?
Is this also true on 64 bit systems?
Note: This answer applies to the C language, not C++.
The integer constant literal 0 has different meanings depending upon the context in which it's used. In all cases, it is still an integer constant with the value 0, it is just described in different ways.
If a pointer is being compared to the constant literal 0, then this is a check to see if the pointer is a null pointer. This 0 is then referred to as a null pointer constant. The C standard defines that 0 cast to the type void * is both a null pointer and a null pointer constant.
Additionally, to help readability, the macro NULL is provided in the header file stddef.h. Depending upon your compiler it might be possible to #undef NULL and redefine it to something wacky.
Therefore, here are some valid ways to check for a null pointer:
if (pointer == NULL)
NULL is defined to compare equal to a null pointer. It is implementation defined what the actual definition of NULL is, as long as it is a valid null pointer constant.
if (pointer == 0)
0 is another representation of the null pointer constant.
if (!pointer)
This if statement implicitly checks "is not 0", so we reverse that to mean "is 0".
The following are INVALID ways to check for a null pointer:
int mynull = 0;
<some code>
if (pointer == mynull)
To the compiler this is not a check for a null pointer, but an equality check on two variables. This might work if mynull never changes in the code and the compiler optimizations constant fold the 0 into the if statement, but this is not guaranteed and the compiler has to produce at least one diagnostic message (warning or error) according to the C Standard.
Note that the value of a null pointer in the C language does not matter on the underlying architecture. If the underlying architecture has a null pointer value defined as address 0xDEADBEEF, then it is up to the compiler to sort this mess out.
As such, even on this funny architecture, the following ways are still valid ways to check for a null pointer:
if (!pointer)
if (pointer == NULL)
if (pointer == 0)
The following are INVALID ways to check for a null pointer:
#define MYNULL (void *) 0xDEADBEEF
if (pointer == MYNULL)
if (pointer == 0xDEADBEEF)
as these are seen by a compiler as normal comparisons.
'\0' is defined to be a null character - that is a character with all bits set to zero. '\0' is (like all character literals) an integer constant, in this case with the value zero. So '\0' is completely equivalent to an unadorned 0 integer constant - the only difference is in the intent that it conveys to a human reader ("I'm using this as a null character.").
'\0' has nothing to do with pointers. However, you may see something similar to this code:
if (!*char_pointer)
checks if the char pointer is pointing at a null character.
if (*char_pointer)
checks if the char pointer is pointing at a non-null character.
Don't get these confused with null pointers. Just because the bit representation is the same, and this allows for some convenient cross over cases, they are not really the same thing.
See Question 5.3 of the comp.lang.c FAQ for more. See this pdf for the C standard. Check out sections 6.3.2.3 Pointers, paragraph 3.
NULL as an integral value of zero. –
Exieexigency if(ptr == zero) ... will fail to translate. If you change it to if(ptr == '\0') ... then all three if statements are equivalent and always check for a null pointer. –
Flori zero with '\0', you will be comparing ptr to all-bits-zero. In the first case, after conversions, you end up with 0xDEADBEEF == 0x00000000, which is false. –
Exieexigency ptr to all-bits-zero. This is not a memcmp, but this is a comparison using a builtin operator. The one side is a null pointer constant '\0', and the other side is a pointer. Aswell as with the other two versions with NULL and 0. Those three do the same things. –
Flori 0xDEADBEEF is still a null pointer, no matter what its bitstring looks like, and it will still compare equal to NULL, 0, \0 and all other null pointer constant forms. –
Flori ptr == '\0'. –
Exieexigency if (!pointer) will ALWAYS means if pointer is not 0 and is ALWAYS a valid way to check for a null pointer in C, as defined by the standard. According to A. Keeton's advice, if (!pointer) would fail on a machine where 0xDEADBEEF is the null pointer –
Inessive !ptr will always be true in this example, no matter the representation of the null pointer. !ptr becomes ptr == 0 which is interpreted as is ptr the null pointer? –
Exieexigency 0x0. It may well be 0xDEADBEEF. But it still compares equal to a null pointer constant. This is the same as true and false and their representation when stored. Now, just because stored false compare equal to 0, that doesn't mean that in binary, a boolean storing false is represented by all-bits-zero. Neither does it mean that if the boolean represents it as all-bits-one, it compares unequal to false. The semantics remain unchanged. –
Flori It appears that a number of people misunderstand what the differences between NULL, '\0' and 0 are. So, to explain, and in attempt to avoid repeating things said earlier:
A constant expression of type int with the value 0, or an expression of this type, cast to type void * is a null pointer constant, which if converted to a pointer becomes a null pointer. It is guaranteed by the standard to compare unequal to any pointer to any object or function.
NULL is a macro, defined in as a null pointer constant.
\0 is a construction used to represent the null character, used to terminate a string.
A null character is a byte which has all its bits set to 0.
0. –
Keratoplasty All three define the meaning of zero in different context.
These three are always different when you look at the memory:
NULL - 0x00000000 or 0x00000000'00000000 (32 vs 64 bit)
NUL - 0x00 or 0x0000 (ascii vs 2byte unicode)
'0' - 0x20
I hope this clarifies it.
sizeof('\0') and be surprised. –
Ivories If NULL and 0 are equivalent as null pointer constants, which should I use? in the C FAQ list addresses this issue as well:
C programmers must understand that
NULLand0are interchangeable in pointer contexts, and that an uncast0is perfectly acceptable. Any usage of NULL (as opposed to0) should be considered a gentle reminder that a pointer is involved; programmers should not depend on it (either for their own understanding or the compiler's) for distinguishing pointer0's from integer0's.It is only in pointer contexts that
NULLand0are equivalent.NULLshould not be used when another kind of0is required, even though it might work, because doing so sends the wrong stylistic message. (Furthermore, ANSI allows the definition ofNULLto be((void *)0), which will not work at all in non-pointer contexts.) In particular, do not useNULLwhen the ASCII null character (NUL) is desired. Provide your own definition
#define NUL '\0'
if you must.
What is the difference between NULL, ‘\0’ and 0
"null character (NUL)" is easiest to rule out. '\0' is a character literal.
In C, it is implemented as int, so, it's the same as 0, which is of INT_TYPE_SIZE. In C++, character literal is implemented as char, which is 1 byte. This is normally different from NULL or 0.
Next, NULL is a pointer value that specifies that a variable does not point to any address space. Set aside the fact that it is usually implemented as zeros, it must be able to express the full address space of the architecture. Thus, on a 32-bit architecture NULL (likely) is 4-byte and on 64-bit architecture 8-byte. This is up to the implementation of C.
Finally, the literal 0 is of type int, which is of size INT_TYPE_SIZE. The default value of INT_TYPE_SIZE could be different depending on architecture.
Apple wrote:
The 64-bit data model used by Mac OS X is known as "LP64". This is the common data model used by other 64-bit UNIX systems from Sun and SGI as well as 64-bit Linux. The LP64 data model defines the primitive types as follows:
- ints are 32-bit
- longs are 64-bit
- long-longs are also 64-bit
- pointers are 64-bit
Wikipedia 64-bit:
Microsoft's VC++ compiler uses the LLP64 model.
64-bit data models
Data model short int long long long pointers Sample operating systems
LLP64 16 32 32 64 64 Microsoft Win64 (X64/IA64)
LP64 16 32 64 64 64 Most Unix and Unix-like systems (Solaris, Linux, etc.)
ILP64 16 64 64 64 64 HAL
SILP64 64 64 64 64 64 ?
Edit: Added more on the character literal.
#include <stdio.h>
int main(void) {
printf("%d", sizeof('\0'));
return 0;
}
The above code returns 4 on gcc and 1 on g++.
'\0' is not a 1-byte value. It's a character literal, which is an integer constant expression - so if it can be said to have a size then it's the the size of an int (which has to be at least 2 bytes). If you don't believe me, evaluate sizeof('\0') and see for yourself. '\0', 0 and 0x0 are all completely equivalent. –
Ivories sizeof('\0') on a C++ compiler. –
Scopoline One good piece which helps me when starting with C (taken from the Expert C Programming by Linden)
The One 'l' nul and the Two 'l' null
Memorize this little rhyme to recall the correct terminology for pointers and ASCII zero:
The one "l" NUL ends an ASCII string,
The two "l" NULL points to no thing.
Apologies to Ogden Nash, but the three "l" nulll means check your spelling.
NUL is a control code such as BEL, VT, HT, SOT etc. and thus has max. 3 characters. –
Harlin A one-L NUL, it ends a string.
A two-L NULL points to no thing.
And I will bet a golden bull
That there is no three-L NULLL.
"NUL" is not 0, but refers to the ASCII NUL character. At least, that's how I've seen it used. The null pointer is often defined as 0, but this depends on the environment you are running in, and the specification of whatever operating system or language you are using.
In ANSI C, the null pointer is specified as the integer value 0. So any world where that's not true is not ANSI C compliant.
A byte with a value of 0x00 is, on the ASCII table, the special character called NUL or NULL. In C, since you shouldn't embed control characters in your source code, this is represented in C strings with an escaped 0, i.e., \0.
But a true NULL is not a value. It is the absence of a value. For a pointer, it means the pointer has nothing to point to. In a database, it means there is no value in a field (which is not the same thing as saying the field is blank, 0, or filled with spaces).
The actual value a given system or database file format uses to represent a NULL isn't necessarily 0x00.
NULL is not guaranteed to be 0 -- its exact value is architecture-dependent. Most major architectures define it to (void*)0.
'\0' will always equal 0, because that is how byte 0 is encoded in a character literal.
I don't remember whether C compilers are required to use ASCII -- if not, '0' might not always equal 48. Regardless, it's unlikely you'll ever encounter a system which uses an alternative character set like EBCDIC unless you're working on very obscure systems.
The sizes of the various types will differ on 64-bit systems, but the integer values will be the same.
Some commenters have expressed doubt that NULL be equal to 0, but not be zero. Here is an example program, along with expected output on such a system:
#include <stdio.h>
int main () {
size_t ii;
int *ptr = NULL;
unsigned long *null_value = (unsigned long *)&ptr;
if (NULL == 0) {
printf ("NULL == 0\n"); }
printf ("NULL = 0x");
for (ii = 0; ii < sizeof (ptr); ii++) {
printf ("%02X", null_value[ii]); }
printf ("\n");
return 0;
}
That program could print:
NULL == 0
NULL = 0x00000001
(void*)0. –
Overplus 0x000000, it may well be (void*)0x00000" then you are right if you talk about C. But if you say "it's not guaranteed to be 0x0000, it may well be 0xDEADBEEF" then you are just bloody wrong, as others already told you. What you "proved" in your code was just that NULL converted to a pointer type can result in an address 0xDEADBEEF. That's why i refuse to talk about NULL pointers. That's just totally confusing terminology. Just say null pointer. –
Flori (void*) 0 is NULL, and '\0' represents the end of a string.
© 2022 - 2024 — McMap. All rights reserved.
NULdoes not exist in the C standard language or library (or in C++ as far as I know). The null character is sometimes called NUL, but it C or C++ it's usually just referred to as'\0'. – Stutz