if( mystruct == NULL )

mystruct is not a pointer, so you cannot compare it with NULL.

You have three options:

1. Add a status field to MyStruct to indicate whether the struct has been initialized correctly.
2. Allocate the struct on the heap and return it by pointer.
3. Pass the structure as a pointer argument and return a status code (thanks @Potatoswatter).

There are several practical reasons why functions like fopen return pointers to instead of instances of struct types:

1. You want to hide the representation of the struct type from the user;
2. You're allocating an object dynamically;
3. You're referring to a single instance of an object via multiple references;

In the case of types like FILE *, it's because you don't want to expose details of the type's representation to the user - a FILE * object serves as an opaque handle, and you just pass that handle to various I/O routines (and while FILE is often implemented as a struct type, it doesn't have to be).

So, you can expose an incomplete struct type in a header somewhere:

typedef struct __some_internal_stream_implementation FILE;

While you cannot declare an instance of an incomplete type, you can declare a pointer to it. So I can create a FILE * and assign to it through fopen, freopen, etc., but I can't directly manipulate the object it points to.

It's also likely that the fopen function is allocating a FILE object dynamically, using malloc or similar. In that case, it makes sense to return a pointer.

Finally, it's possible you're storing some kind of state in a struct object, and you need to make that state available in several different places. If you returned instances of the struct type, those instances would be separate objects in memory from each other, and would eventually get out of sync. By returning a pointer to a single object, everyone's referring to the same object.

You have a lot of options:

1. Give AUTO a way to represent a "no-value". For example by making weight -1. Or by adding a flag to it. This is pretty ugly; I don't recommend it, even though it's somewhat common in practice.
2. Return a (smart) pointer instead of value. This way you can return a nullptr in the case of error / no value. This is also ugly because it forces you to deal with pointers for not a very good reason.
3. Return a separate value to indicate success. For example adding a bool &wasFound argument to the function.
4. Return boost::optional or std::pair<AUTO, bool> to accomplish pretty much the same thing, but all wrapped up in the return value. This is probably the cleanest. This is how std::map::find works, for example.
5. Throw an exception. It's possible that this is acceptable if callers don't try to find items that don't exist. In other words, if "not found" is just a return value then don't throw an exception. If "not found" is truly a program error condition, throwing an exception may actually make sense. If you're not sure, don't throw an exception.

I'd recommend #4, or in rarer cases #5.

C++ objects can never be null or empty. Pointers can hold a null pointer value indicating they point at nothing.

The typical solution would be to throw an exception. Otherwise, use a pointer; just make sure you aren't returning the address of a temporary.

I wouldn't recommend trying to teach yourself C++ with knowledge from other languages, you'll hurt yourself. Grab a good beginner-level book, it's the best way to learn.

Maybe there are some basic things you should rethink: First, only pointers can be NULL, but not objects. Hence, if you return an object of type struct Stack (which is not a pointer), you cannot return NULL but just an instance of struct Stack.

Second, passing in and returning an object of struct Stack by value will result in copying the respective object; I think that passing references or pointers would be a better choice; and - if you pass in and return a pointer, you could also return NULL to indicate a full stack or some other issue.

If the return type is int, you can't return a NULL. To show an error, you could instead return a special value like zero or -1, if you check for that value in any calling function. Lots of functions return nonnegative numbers on success, or -1 on error.

NULL cannot be stored in an int variable, unlike in SQL, for example. If you ignore the warning and return NULL anyway, then NULL will be casted to zero. The calling function won't be able to tell whether you returned NULL or zero.

If your function only needs to indicate success or failure, then it's common to return 1 for success, and zero for failure. Zero means "false" when treated as a boolean value (like in if statements), and non-zero means "true."

It seems as if the Node *head is passed by value and not by reference.

That is exactly right -- in C every parameter is always passed by value. The pointer is a value, and that value is passed by value, and the call

Insert(head, 25);

can never change the value of the variable named head. It reads the value of the variable (this value is a null pointer), gives that value to the function and never touches the variable head again no matter what the function does.

(Note that in your program you have two variables that are both named head -- one in main() and the other in Insert(). The variable in Insert() silently disappears when the function returns; nothing will automatically try to copy its value to the similarly-named variable in main()).

If you want to (conceptually) pass head by reference, you need to actually pass a pointer to it -- that is, in this case, a pointer to a pointer! You'd need to declare your function as

void Insert(Node **head, int x) { ... }

and call it as

Insert(&head, 25);

Then the actual parameter is a pointer to the variable head which gives the function a chance to update that variable, if you deference the parameter where appropriate:

// ...
temp->next = *head;
// ...
*head = temp;
// ...

This line (after the '*' removal) does exactly nothing as it only changes the local headNode parameter ( and 100% will be removed completely by the compiler)

 headNode = NULL;

If you want to assign NULL to the higher level pointer you need to pass node **headnode to this function or make it node *:. 1.

void clear(node** headNode){
    node* nextNode;
    if (*headNode == NULL) return;
    while (*headNode -> next != NULL){
        nextNode = *headNode -> next;
        free(*headNode);
        *headNode = nextNode;
    }
    *headNode = NULL;
}

and the call

 clear(&list);

or better

node *clear(node* headNode){
    node* nextNode;
    if (headNode == NULL) return;
    while (headNode -> next != NULL){
        nextNode = headNode -> next;
        free(headNode);
        headNode = nextNode;
    }
    return NULL;
}

and the call :

list = clear(list);