This is just an initializer list for an array. So it's very like the normal syntax:

char buf[5] = { 1, 2, 3, 4, 5 };

However, the C standard states that if you don't provide enough elements in your initializer list, it will default-initialize the rest of them. So in your code, all elements of buf will end up initialized to 0.

printf doesn't display anything because buf is effectively a zero-length string.

The null character '\0' (also null terminator), abbreviated NUL, is a control character with the value zero. Its the same in C and objective C

The character has much more significance in C and it serves as a reserved character used to signify the end of a string,often called a null-terminated string

The length of a C string (an array containing the characters and terminated with a '\0' character) is found by searching for the (first) NUL byte.

As Dani's own @rubberman has indicated ... the char '0' has the ASCII int value of 48 · But you do not need to worry about memorizing that (48) value, as you can convert form char to int for the digits 0...9 very easily like this: · /* problem3.c */ · #include · int main() · { · const int ary[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; · const int size = sizeof ary / sizeof *ary; · int i; · char buf[256]; · const char* numStr = "123456789"; · const char* p = numStr; · int sum = 0; · while( *p != 0 ) · { · sum += *p - '0'; · ++ p; · } · printf( "The sum for 1 to 9 is %d\n", sum ); · for( i = 0; i < size; ++ i ) · { · buf[i] = i + '1'; /* OR: i+1 + '0'; */ · } · buf[size] = 0; /* terminate C string with '\0' char ...*/ · printf( "\nHere are the digits 1..9 placed into a C string: %s\n", buf ); · fputs( "\nPress 'Enter' to continue.exit ... ", stdout ); · fflush( stdout ); · getchar(); · return 0; · }

NULL is a macro that expands to a null pointer constant. 0 is a null pointer constant. That means NULL could just be defined as 0. Put simply, sizeof (NULL) is simply not something you can rely on as having a consistent, implementation-independent meaning — you don't even know what type NULL has. It is entirely possible for sizeof (NULL) to be not equal to sizeof (void *). If you want to know how big a particular pointer type is, use sizeof on that pointer type, or on a value of that pointer type.

In C the main function has to return an integer. A zero has been established as the code for success, but other numbers have been used as exit codes to return a variety of messages. Here's an example list of Window's exit codes: http://www.hiteksoftware.com/knowledge/articles/049.htm

On a Unix-like system, when you return 0 from main(), the following things happen: Control returns to the program entry point, _start, which is part of the C runtime for that system. The code in _start calls exit(0), or something which has the same effect. All functions registered with atexit() are called, destructors are run. The exit() function invokes the exit syscall, which transfers control to the kernel. The kernel reclaims all the resources that the process was using, except for the one record—a record which says that the process exited with status 0. The program’s parent process, at some point, calls wait() or a similar syscall. This function will clean up that last record in the kernel, and report the exit status. That program can do whatever it wants with the 0. When you run a program in a shell, the shell is the parent process. The shell keeps track of that 0. If you run another program after yours with &&, then the shell will run that next program. If you use ||, it won’t. This isn’t really special — it’s just what the shell is programmed to do.

Note: This answer applies to the C language, not C++.

---

Null Pointers

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.

Null Characters

'\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.

References

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.

Boolean/logical operators in C are required to yield either 0 or 1.

From section 6.5.3.3/5 of the ISO C99 standard:

The result of the logical negation operator ! is 0 if the value of its operand compares unequal to 0, 1 if the value of its operand compares equal to 0.

In fact, !!x is a common idiom for forcing a value to be either 0 or 1 (I personally prefer x != 0, though).

Also see Q9.2 from the comp.lang.c FAQ.