Void is considered a data type (for organizational purposes), but it is basically a keyword to use as a placeholder where you would put a data type, to represent "no data".

Hence, you can declare a routine which does not return a value as:

void MyRoutine();

But, you cannot declare a variable like this:

void bad_variable;

However, when used as a pointer, then it has a different meaning:

void* vague_pointer;

This declares a pointer, but without specifying which data type it is pointing to.

In C language the void type has been introduced with the meaning of 'don't care' more than 'null' or 'nothing', and it's used for different scopes.

The void keyword can reference a void type, a reference to void, a void expression, a void operand or a void function. It also explicitly defines a function having no parameters.

Let's have a look at some of them.

The void type

First of all void object exists and have some special properties, as stated in ISO/IEC 9899:2017, §6.2.5 Types:

19. The void type comprises an empty set of values; it is an incomplete object type that cannot be completed.

Pointers

The more useful reference to void, or void *, is a reference to an incomplete type, but itself is well defined, and then is a complete type, have a size, and can be used as any other standard variable as stated in ISO/IEC 9899:2017, §6.2.5 Types:

28. A pointer to void shall have the same representation and alignment requirements as a pointer to a character type.

    Similarly, pointers to qualified or unqualified versions of compatible types shall have the same representation and alignment requirements.

    All pointers to structure types shall have the same representation and alignment requirements as each other.

    All pointers to union types shall have the same representation and alignment requirements as each other.

    Pointers to other types need not have the same representation or alignment requirements.

Casting to void

It can be used as cast to nullify an expression, but allowing the completion of any side effect of such expression. This concept is explained in the standard at ISO/IEC 9899:2017, §6.3 Conversions, §6.3.2.2 void:

1. The (nonexistent) value of a void expression (an expression that has type void) shall not be used in any way, and implicit or explicit conversions (except to void) shall not be applied to such an expression.

   If an expression of any other type is evaluated as a void expression, its value or designator is discarded. (A void expression is evaluated for its side effects.)

A practical example for the casting to void is its use to prevent warning for unused parameters in function definition:

int fn(int a, int b)
{
    (void)b;    //This will flag the parameter b as used 

    ...    //Your code is here

    return 0;
}

The snippet above shows the standard practice used to mute compiler warnings. The cast to void of parameter b acts as an effective expression that don't generate code and marks b as used preventing compiler complains.

void Functions

The paragraph §6.3.2.2 void of the standard, covers also some explanation about void functions, that are such functions that don't return any value usable in an expression, but functions are called anyway to implement side effects.

void pointers properties

As we said before, pointers to void are much more useful because they allow to handle objects references in a generic way due to their property explained in ISO/IEC 9899:2017, §6.3.2.3 Pointers:

1. A pointer to void may be converted to or from a pointer to any object type.

   A pointer to any object type may be converted to a pointer to void and back again; the result shall compare equal to the original pointer.

As practical example imagine a function returning a pointer to different objects depending on input parameters:

enum
{
    FAMILY,     //Software family as integer
    VERSION,    //Software version as float
    NAME        //Software release name as char string
} eRelease;

void *GetSoftwareInfo(eRelease par)
{
    static const int   iFamily  = 1;
    static const float fVersion = 2.0;
    static const *char szName   = "Rel2 Toaster";

    switch(par)
    {
        case FAMILY:
            return &iFamily;
        case VERSION:
            return &fVersion;
        case NAME:
            return szName;
    }
    return NULL;
}

In this snippet you can return a generic pointer that can be dependent on input par value.

void as functions parameter

The use of void parameter in functions definitions was introduced after the, so called, ANSI-Standard, to effectively disambiguate functions having variable number of arguments from functions having no arguments.

From standard ISO/IEC 9899:2017, 6.7.6.3 Function declarators (including prototypes):

10. The special case of an unnamed parameter of type void as the only item in the list specifies that the function has no parameters.

Actual compilers still support function declaration with empty parenthesis for backward compatibility, but this is an obsolete feature that will eventually be removed in future release of standard. See Future directions - §6.11.6 Function declarators:

1. The use of function declarators with empty parentheses (not prototype-format parameter type declarators) is an obsolescent feature.

Consider the following example:

int foo();         //prototype of variable arguments function (backward compatibility)
int bar(void);     //prototype of no arguments function
int a = foo(2);    //Allowed
int b = foo();     //Allowed
int c = bar();     //Allowed
int d = bar(1);    //Error!

Now resembling your test, if we call the function bar as follows:

int a = 1;
bar((void)a);

Triggers an error, because casting to void an object doesn't null it. So you are still trying to pass a void object as parameter to a function that don't have any.

Side effects

As requested this is a short explain for side effects concept.

A side effect is whichever alteration of objects and values derived from the execution of a statement, and which are not the direct expected effect.

int a = 0;
(void)b = ++a;

In the snippet above the void expression lose the direct effect, assigning b, but as side effect increase the value of a.

The only reference, explaining the meaning, in the standard can be found in 5.1.2.3 Program execution:

2. Accessing a volatile object, modifying an object, modifying a file, or calling a function that does any of those operations are all side effects, which are changes in the state of the execution environment.

   Evaluation of an expression in general includes both value computations and initiation of side effects.