Understanding double void pointers in C

Question

I'm trying to do very basic examples to understand how void pointers work. Here's an example I've written for having a void* string and casting it to its "working" type and printing some aspects of it:

int main(int argc, char *argv[]) {

    // Create a void pointer which "acts like" a string
    void * string = "hello";

    // "Cast" the string so it's easier to work with
    char * string_cast = (char*) string;

    // Print the string and a character in it
    printf("The string is: %s\n", string_cast);
    printf("The third character is: %c\n", string_cast[2]);

    // How to now do something like:
    // (1) void pointer_to_string_obj = ?
    // (2) cast that pointer_to_string_obj to a normal string
    // (3) print the string like it would normally be done


}

Could someone please show an example of manually creating a string pointer of type *(char**) and why that type would need to be created in the first place (why not just a normal char*?). I apologize if my question is broad, but basically I'm trying to figure out various void pointer types and where I'm at now in my very beginner understanding, it's a bit confusing, and so seeing a few examples would be very helpful.

Answer 1

So I thought up a kind of a good example of double void pointer (that is, void**). One way to cut down on double-free bugs is to always set pointers to NULL after freeing them.

We could do so like so (questionable style):

myprojectinclude.h:

/* must happen after any standard headers */
void freep(void **pointer);
#define free(p) error_call_freep_instead p /* so that free doesn't exist anymore */

freep.c:

#include <stdlib.h>
#include "myprojectinclude.h"

#undef free
void freep(void **p)
{
    if (p) {
        free(*p);
        *p = NULL;
    }
}

main.c:

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

int main()
{
     char *buffer = malloc(2048);
     size_t buffer_size = 2048;

     /* ... lots of code involving reading lines, etc. */

     freep(&buffer);

     /* buffer is guaranteed to be NULL here */
}

With this setup, double free is impossible. If we do

     freep(&buffer);
     freep(&buffer);

nothing goes wrong because buffer is NULL after the first call. (Note that passing NULL to free is safe; else we would add a NULL check like I had to do decades ago.)

Summary of portability debate in comments: This code assumes all data pointers are the same size and representation (mostly--the old 36 bit platform with same size and different bit layout for int* and char* had NULL look the same for both). There used to exist platforms for which this was not true. This code works on Unix, DOS, Windows, and most others.