Reading through an char array passed as void* with pointer incrementation and later read as chars and other datatypes?

So to clear out misunderstandings from the title (not sure how to ask the question in the title) I want to read from a file(char array), pass it as an void* so i can read undependable of datatype by incrementing the pointer. So here's an simple example of what I want to do in C code:

char input[] = "D\0\0Ckjh\0";
char* pointer = &input[0];       //lets say 0x00000010 
char type1 = *pointer;           //should be 'D'
pointer += sizeof(char);         //0x00000020
uint16_t value1 = *(uint16_t*)pointer; //should be 0
pointer += sizeof(uint16_t);     //0x00000040
char type2 = *pointer;           //should be 'C'
pointer += sizeof(char);         //0x00000050
uint32_t value2 = *(uint32_t*)pointer; //should be 1802135552

This is just for educational purpose, so I would just like to know if it is possible or if there is a way to achieve the same goal or something alike. Also the speed of this would be nice to know. Would it be faster to just keep the array and just make bitshifting on the chars as you read them or is this actually faster?

Edit: edit on the c code and changed void* to char*;

This is wrong in two ways:

1. void is an incomplete type that cannot be completed. An incomplete type is a type without a known size. In order to do pointer arithmetics, the size must be known. The same is true for dereferencing a pointer. Some compilers attribute the size of a char to void, but that's an extension you should never rely on. Incrementing a pointer to void is wrong and can't work.

2. What you have is an array of char. Accessing this array through a pointer of a different type violates strict aliasing, you're not allowed to do that.

   That's actually not what your current code does -- looking at this line:

   uint32_t value2 = (int)*pointer; //should be 1802135552
   

   You're just converting the single byte (assuming your pointer points to char, see my first point) to an uint32_t. What you probably meant is

   uint32_t value2 = *(uint32_t *)pointer; //should be 1802135552
   

   which might do what you expect, but is technically undefined behavior.

The relevant reference for this second point is e.g. in §6.5 p7 in N1570, the latest draft for C11:

An object shall have its stored value accessed only by an lvalue expression that has one of the following types:
— a type compatible with the effective type of the object,
— a qualified version of a type compatible with the effective type of the object,
— a type that is the signed or unsigned type corresponding to the effective type of the object,
— a type that is the signed or unsigned type corresponding to a qualified version of the effective type of the object,
— an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or
— a character type.

The reasoning for this very strict rule is for example that it enables compilers to do optimizations based on the assumption that two pointers of different types (except char *) can never alias. Other reasons include alignment restrictions on some platforms.