No, in this case you're pointing to a real (non-null) string with a length of 0. You can simply do the following to set it to actual null:

char* str = NULL;

string is ends with null character(\0), how can "e" be output?

The string literal "App\0le" is stored in memory as an unnamed character array having the following elements

char unnamed_string_literal[7] =  { 'A', 'p', 'p', '\0', 'l', 'e', '\0' };

This declaration

char *str = "App\0le";

may be rewritten taking into account the above assumption the following way

char *str = unnamed_string_literal;

So using the pointer arithmetic and knowing a priori the number of elements in the string literal (including its embedded zero character) you can output any elements of the character array that represents the string literal.

For example

#included <stdio.h>

int main( void )
{
    char *str = "App\0le";

    for (size_t i = 0; i < 7; i++)
    {
        if (str[i] == '\0')
        {
            putchar( '\\' ), putchar( '0' );
        }
        else
        {
            putchar( str[i] );
        }
    }

    putchar( '\n' );
}

The program output is

App\0le\0

That is the expression str[i] is an expression of accessing i-th element of an array. It is totally unimportant what the type of the array and what it stores.

If you will write

char *str2 = str;

then the pointer str2 will point to the first character of the same string literal pointed to by the pointer str.

If you need to get a string then you need to declare a character array as for example

char str2[6];

and copy to it characters of the string literal pointed to by the pointer str excluding the embedded zero character but including the terminating zero character. You may not change the string literal itself because any attempt to change a string literal results in undefined behavior.

For example (without using standard C string functions)

#include <stdio.h>

int main( void )
{
    char *str = "App\0le";
    char str2[6];

    size_t i = 0;

    while (( str2[i] = str[i] ) != '\0') i++;
    while (( str2[i] = str[i + 1] ) != '\0') i++;

    puts( str2 );
}

The program output is

Apple

Determination of the terminating character is up to the compiler for literals and the implementation of the standard library for strings in general. It isn't determined by the operating system.

The convention of NUL termination goes back to pre-standard C, and in 30+ years, I can't say I've run into an environment that does anything else. This behavior was codified in C89 and continues to be part of the C language standard (link is to a draft of C99):

• Section 6.4.5 sets the stage for NUL-terminated strings by requiring that a NUL be appended to string literals.
• Section 7.1.1 brings that to the functions in the standard library by defining a string as "a contiguous sequence of characters terminated by and including the first null character."

There's no reason why someone couldn't write functions that handle strings terminated by some other character, but there's also no reason to buck the established standard in most cases unless your goal is giving programmers fits. :-)

Always be careful to allocate enough memory with strings, compare the effects of the following lines of code:

char s1[3] = "abc";
char s2[4] = "abc";
char s3[] = "abc";

All three are considered legal lines of code (http://c-faq.com/ansi/nonstrings.htmlhttp://c-faq.com/ansi/nonstrings.html), but in the first case, there isn't enough memory for the fourth null-terminated character. s1 will not behave like a normal string, but s2 and s3 will. The compiler automatically count for s3, and you get four bytes of allocated memory. If you try to write

s1[3] = '\0';

that's undefined behavior and you're writing to memory that doesn't belong to s1, and would have weird effects, maybe even disrupting malloc's backend information, making it hard to free memory.