In some programming languages [...] it is possible to pass a NULL parameter as an argument, but in C I always thought this would result in Undefined Behavior.

Passing a NULL parameter for a pointer by itself does not result in UB; it's attempting to access the memory pointed to by a pointer set to NULL that does.

Passing NULL is a very common practice for situations when something is not specified. The caller is expected to check parameters for NULL before performing the access. For example, the standard lets you pass NULL to free, which makes the function a lot more convenient.

don't NULL pointers simply point to nothing?

Yes, they do. But that "nothing" is globally well-known, so using a NULL lets you communicate the fact that a pointer points to nothing to functions that you call. In other words, the check

if (myPointer == NULL)

is well-defined^*, so you can use it to your advantage.

^* Unless you use a dangling pointer, i.e. a pointer that you have freed, or a pointer that points to object that went out of scope. You can prevent the first situation from happening by assigning NULL to every pointer that you free(), and the second situation by declaring pointers in the scope that has the same or higher level of nesting as the scope of an automatic object to which the pointer is pointing.

Macro expansion is just text replacement, so when you passed NULL, it will expand to NULL->member, clearly it is an error. One way is to use a temporary variable for that:

#define macro1(arg1) \
 do{ \
  A* p = (arg1);
  int _state = 0; \
  if (p && p->member_) \
    _state = p->member_->state_; \
  printf("%d", _state); \
 } while(0)

A *a = new A():
macro1(a);
macro1(NULL);

This way both cases will work.

The referenced article is wrong and should be disregarded.

1. Assuming that NULL was 32-bit int 0 on a system, wouldn't compiler do an implicit cast of 32-bit - int to 64-bit 0 when it encounters char *string = NULL.

An assignment automatically converts the right operand to the type of the left operand. So char *string = NULL will convert the NULL value to char *, not to “64-bit 0”.

If not, then are we saying that each expression like char *string = NULL is non-portable and must be always replaced with an explicit cast like char *string = (char *)NULL for portable C?

No, char *string = NULL is portable C code; it is strictly conforming.

2. If NULL was 32-bit int 0, and char *string was 64-bit then why would printf run out of bits to print like it is suggested in the blue highlight. Shouldn't printf get full 64 bits as it was passed string and not NULL.

The code referenced, char* string = NULL; followed by printf("%s %d\n", string, 1);, does not pass NULL to printf. It passes string to printf, and the prior assignment converts NULL to char *. So printf is passed a char * that has the value of a null pointer. This will not cause any problem in interpreting the variable arguments to printf. (It is, however, improper to pass a null pointer for the %s conversion.)

If the call were instead printf("%s", NULL);, then there is a problem. Arguments corresponding to the ... part of a variable-argument function are not automatically converted to a parameter type. They are processed by the default argument promotions, which largely promote narrow integer types to int and promote float to double, but they will not convert an int to any type of pointer. Thus, if NULL is defined as 0, then printf("%s", NULL); passes an int where a char * is expected, and this may cause various misinterpretations of the arguments.

In consequence, never use the NULL macro as a direct argument to a function with a variable argument list. Using a pointer variable that has been assigned from NULL is okay.

I'm going to guess what you really mean with your question and try to give a decent answer.

I guess you want to change num_results to be equal to num by passing it to the function set as a pointer, and I can see a few mistakes you've made:

1. You probably have this in your full code, but don't forget to #include <stdio.h> to use printf() and to #include <stdlib.h> to use malloc()
2. Your function set() should be declared before main(), you can do this by declaring a prototype before main() or simply defining the set() function before main().

Now let's go to your solution: you want to pass the num_results as a parameter to a function, allocate some memory and assign the address to num_results and then update the value to the one in num.

When you pass an int * as a parameter, I guess you already know that by passing int you are simply giving a copy of what is inside an int variable. This works the same way with an int *, you are not passing a reference to num_results so that you can update the address of the pointer, you are passing a copy of the current address, NULL, which will not be modified. What could be modified is what is inside of the current address, but the current address is NULL, so not can really be modified.

Since you want to allocate memory and assign its address to num_results, you must pass a pointer to a pointer, so you are passing the address of where your int* variable is being kept and where you can actually change it.

This way, your function should look like void set(int ** results, int num) and you should call it with set(&num_results, num), so you are passing a reference to num_results, where you can change the address it points to, currently NULL and then the address returned by malloc().

You'd also have to change the body of your function, because you're now using an int **, you want to assign the new address to *results, because results == &num_results, and assign num to **results, because *results = num_results.

I hope my explanation is not very confusing and hopefully someone can explain it better with another answer or by editing mine. Final code:

#include <stdio.h>
#include <stdlib.h>

void set(int ** results, int num){
    *results = malloc(sizeof(int));
    **results = num;
}

int main(void) {
    int * num_results = NULL;
    int num = 4;
    set(&num_results, num);
    printf("%d\n", *num_results);
    return 0;
}

void displayNum(int n, int first, int second, int third, int fourth, int fifth){
    switch(n){
        case 5:printf("%d", fifth);
        case 4:printf("%d", fourth);
        case 3:printf("%d", third);
        case 2:printf("%d", second);
        case 1:
            printf("%d", first);
            break;
        default: printf("wrong n value\n");
    }
}

You cannot.

The C program receives arguments as zero-terminated strings. Such a string cannot contain a null character, by definition.

If you want to pass a null character, then you must somewhat encode it with some syntax, and your C program must then decode it by interpreting that syntax.

Look at exactly what this code does:

void setCharacter(char* pCharacter)
{
     pCharacter = malloc(sizeof(char));
    *pCharacter = 'b';
}

Remember that things get passed by copy. First, pCharacter is an address that's passed from main to setCharacter. Then setCharacter changes that address by malloc'ing new memory and assigning the address of that memory to the local pCharacter. Note that it doesn't change the contents of pCharacter in main. That doesn't mean much here because the address passed in to setCharacter was NULL.

If you wanted to both allocate new memory and initialize the contents of that memory, it isn't necessary to pass in any variables here, but the process isn't complete.

The problem that you're having is this. While setCharacter is allocating new memory and initializing the contents (to 'b', in this case), it isn't returning any information to main. The address of the new memory is only known to setCharacter. You would need to return the address to main. So, depending on how much you would want setCharacter to do, there are two ways to do it. One just sets the contents, the other would both allocate the memory and set the value.

Method 1:

int main (void)
{
    char* pCharacter = malloc(sizeof(char));

    setCharacter(pCharacter);
    printCharacter(pCharacter);
}

void setCharacter(char* pCharacter)
{
    //this would only set the contents using the address from main
    *pCharacter = 'b';
}

Method 2:

int main (void)
{
    // the next line will create pCharacter pointer
    // and will initialize with the call to setCharacter
    char* pCharacter = setCharacter();
    printCharacter(pCharacter);
}

char * setCharacter(void)
{
     // this will both allocate memory and set the contents
     char *pCharacter = malloc(sizeof(char));
    *pCharacter = 'b';
     return pCharacter;
}

Note that you need to update the function signatures.

If this answers your questions, please click on the check mark to accept. Let's keep up on forum maintenance. ;-)