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.

First some background ...

The macros are NULL which expands to an implementation-defined null pointer constant; C11 §7.19 3

NULL typically is an integer constant 0 or (void*)0 or the like. It may have a different implementation or type - It could be ((int*) 0xDEADBEEF) as strange as that may be.

NULL might be type int. It might be type void * or something else. The type of NULL is not defined.

When the null pointer constant NULL is cast to any pointer, is is a null pointer. An integer 0 cast to a pointer is also a null pointer. A system could have many different (bit-wise) null pointers. They all compare equally to each other. They all compare unequally to any valid object/function. Recall this compare is done as pointers, not integers.

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant. If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function. C11 §6.3.2.3 3

int x;
if (&x == NULL) ... // this is false

So after all that chapter and verse how to distinguish NULL from 0?

If the macro NULL is defined as an int 0 - it is game over - there is no difference between 0 and NULL.

If NULL is not an int, then code can use _Generic() to differentiate NULL and 0. This does not help OP's "Any change made can only be made within the function itself." requirement as that function accepts an int augment.

If NULL is an int that has a different bit-pattern than 0, then a simple memcmp() can differentiate.

I suspect the whole reason for this exercise is to realize there is no portable method to distinguish NULL from 0.

I think @R Sahu's answer reaches the right conclusion, but the supporting evidence it provides (based on a single implementation) is somewhat weak, at best.

This is tagged with both c and c++. The details of how NULL is defined vary between the two, and also varies over time for C++. In all cases, NULL must expand to an "implementation defined null pointer constant". What varies is the definition of "null pointer constant".

In C, a null pointer constant must be an integer literal with the value 0, or the same cast to type "pointer to void"¹. An integer with a non-zero value (by itself, or cast to type "pointer to void") is not allowed². So, 0, 0L and ((void *)0) are all allowed, but something like ((void *)1234) is not.

In C++ 98/03, NULL must also expand to a null pointer constant--but with a somewhat different definition of the term--in particular, casting the integer literal to type "pointer to void" is not allowed in C++ 98/03. This means 0 and 0L are both allowed (and so would '\0' or, if you wanted to be really perverse, (3-(2 + 1)).

In C++ 11, the nullptr_t type and nullptr literal were added to C++, and nullptr is also allowed as a null pointer constant³. NULL is allowed to expand to any null pointer constant, so it could be 0, 0L (etc.) or nullptr, but (again) cannot be any non-zero integer, nor can it have type "pointer to void" (or "pointer to char", etc.)

The intent, however, has always been that NULL only be used to represent a null pointer. Although both C and C++ allow it to be defined as an unadorned 0 (for one example), so it might be possible to assign it to a variable of type int, there's no guarantee that code that does so will even compile (and a fair number of people believe that it shouldn't compile).

Conclusion: you should only ever assign NULL to a pointer. For new code, I'd advise using NULL only in C, and using nullptr in C++. For existing C++ code, I'd convert to using nullptr when any other refactoring is being done on that code, but would not usually modify the code solely to change NULL to nullptr (but code that assigns NULL to any non-pointer type should be corrected immediately, in either C or C++).

^{1. The wording in the C standard (§6.3.2.3/3) reads:}

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant.

^{The italics (which are in the original) mean that this is considered the definition of that term for this standard.}

^{2. Assigning a null pointer constant to a pointer variable may result in a non-zero value being stored into that variable. Although somewhat unusual, this is perfectly allowable. Even if/when that is the case, however, comparing that variable to a null pointer constant (e.g., NULL or 0) must yield true.}

^{Likewise, an implementation is free to define any number of other integer constants that will produce a null pointer when assigned to a pointer variable. This doesn't affect the requirement on how NULL must be defined.}

^{3. Here, the official wording (from [conv.ptr]) reads:}

A null pointer constant is an integer literal (2.13.2) with value zero or a prvalue of type std::nullptr_t.

^{Here again, the italics indicate that this is the official definition of the term for that standard.}

Using the constant 0 (or any constant expression evaluating to 0) anyplace where NULL would be used is safe, as 0 is a null pointer constant.

This is defined in section 6.3.2.3p3 of the C99 (and C11) standards state:

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant.⁵⁵⁾ If a null pointer constant is converted to a pointer type, the resulting pointer,called a null pointer ,is guaranteed to compare unequal to a pointer to any object or function.

So 0, when converted to a pointer type, is guaranteed to be converted to a null pointer regardless of how that particular system implements a null pointer.

Footnote 55 (66 in C11) from the above quote states:

The macro NULL is defined in <stddef.h> (and other headers) as a null pointer constant.

Using my CentOS7 system as an example, it defines NULL as:

#define NULL ((void *)0)

While using 0 in place of NULL is safe, it is not completely equivalent, for example if it is used in a context doesn't necessarily expect a pointer. As an example, sizeof(0) would evaluate to the size of an int, while sizeof(NULL) would (on my system at least) evaluate to the size of a void *.

The reverse, using NULL in place of 0, is not the same. If you had this:

int x[5] = { 3, 4, 5, 6, 7 };
int *p = x + 0;

And replaced it with:

int x[5] = { 3, 4, 5, 6, 7 };
int *p = x + NULL;

The code would fail to compile since two pointers cannot be operands of the + operator.

Another example:

int x[5] = { 3, 4, 5, 6, 7 };
void *p = (void *)x - 0;
printf("*p = %d\n", (int *)p);

While not strictly conforming to the standard, some implementations (like gcc) allow pointer arithmetic on void * types and would result in 3 being printed. If you changed out 0 for NULL:

int x[5] = { 3, 4, 5, 6, 7 };
void *p = (void *)x - NULL;
printf("*p = %d\n", (int *)p);

If you ran this code on a system that 1) allowed void * arithmetic and 2) used a non-zero address for a null pointer, you would be creating and dereferencing a pointer pointing before the start of the array and possibly not correctly aligned.

§ 6.3.2.3 of the C99 standard says

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant) If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.

§ 7.17 also says

[...] NULL which expands to an implementation-defined null pointer constant [...]

The address of the NULL pointer might be different from 0, while it will behave like it was in most cases.

(This should be the same as in older C standards, which I don't have at hand right now)