10

I am writing a function where i would like to accept 2 types of parameters.

  • A string (char *)
  • A structure where there will be n number of elements.

And to achieve this i am thinking of using a simple void * as parameter type. But i do not know how to verify if the parameter is one type or the other, safely.

localhost
  • 146
  • 10
  • 10
    You can't! At the very least, you will need to add a second parameter to the function, which indicates what the `void*` points to. – Adrian Mole Oct 08 '19 at 05:17
  • 4
    ... and if you have to add a second parameter anyway, you could just as well write two separate functions `func_str` and `func_struct` and get type checks at compile time. – M Oehm Oct 08 '19 at 05:31
  • Yeah that's why i was thinking if it was possible in one function only – localhost Oct 08 '19 at 05:37
  • 1
    You cannot in a safe and portable way. If you are brave enough you can try to use heuristics to try and guess whether the first bytes of memory look like what you could expect for characters, but I would not call that *safe*. – Serge Ballesta Oct 08 '19 at 05:49
  • If you just want a common name for the string and struct functions, you could use a `_Generic` macro. You could also create self-identifying types, for example with [tagged unions](https://en.wikipedia.org/wiki/Tagged_union), which would mean that you can't pass a raw `char *`string. All that is probably more trouble than it's worth. – M Oehm Oct 08 '19 at 06:09

3 Answers3

14

The translation of void* is
"Dear compiler, this is a pointer, an there is no additional information for you on this.".

Usually the compiler knows better than you (the programmer), because of information he got earlier and still remembers and you might have forgotten about.
But in this special case, you know better or need to know better. In all cases of void* the information is available otherwise, but only to the programmer, who "happens to know". The programmer therefor has to provide the information to the compiler - or better to the running program, because the one advantage a void* has is that the information can change during runtime.
Usually that is done by giving the information via additional parameters to functions, sometimes via context, i.e. the program "happens to know" (e.g. for each possible type there is a separate function, whichever function gets called implies the type).

So in the end void* does not contain the type info.
Many programmers misunderstand this as "I don't need to know the type info".
But the opposite is true, the use of void* increases the responsibility of the programmer to keep track of the type info and provide it appropriatly to the program/compiler.

Yunnosch
  • 26,130
  • 9
  • 42
  • 54
  • In addition, the compiler actually knows what the type of data pointed-at is. So if you jump into some `void*` function, cast to the wrong type, then de-reference the data... then all manner of undefined behavior is invoked. – Lundin Oct 08 '19 at 11:52
6

void* are kind of deprecated for generic programming, there aren't many situations where you should use them nowadays. They are dangerous because they lead to non-existent type safety. And as you noted, you also lose the type information, meaning you'd have to drag around some cumbersome enum along with the void*.

Instead you should use C11 _Generic which can check types at compile-time and add type safety. Example:

#include <stdio.h>

typedef struct
{
  int n;
} s_t; // some struct

void func_str (const char* str)
{
  printf("Doing string stuff: %s\n", str);
}

void func_s (const s_t* s)
{
  printf("Doing struct stuff: %d\n", s->n);
}

#define func(x) _Generic((x),              \
  char*: func_str, const char*: func_str,  \
  s_t*:  func_s,   const s_t*:  func_s)(x) \


int main()
{
  char str[] = "I'm a string";
  s_t s = { .n = 123 };

  func(str);
  func(&s); 
}

Remember to provide qualified (const) versions of all types you wish to support.

If you want better compiler errors when the caller passes the wrong type, you could add a static assert:

#define type_check(x) _Static_assert(_Generic((x), \
  char*:   1,  const char*: 1,  \
  s_t*:    1,  const s_t*:  1,  \
  default: 0), #x": incorrect type.")

#define func(x) do{ type_check(x); _Generic((x),     \
  char*: func_str, const char*: func_str,            \
  s_t*:  func_s,   const s_t*:  func_s)(x); }while(0)

If you try something like int x; func(x); you'll get the compiler message "x: incorrect type".

Lundin
  • 195,001
  • 40
  • 254
  • 396
0

I recommend you wrapping your arguments with something like:

#include <stdio.h>

struct WrappedArg{
    int Type;
    void* Pointer;
};
typedef struct WrappedArg WrappedArg;


struct Other_Structure{
    int x, y, z;
};
typedef struct Other_Structure Other_Structure;


void Our_Function(void* data){
    WrappedArg* translated_data = (WrappedArg*) data;

    if(translated_data->Type == 0){

        // print srting, if string passed
        printf("You passed string: %s\n", (char*) translated_data->Pointer);
        

    } else {

        // recreate structure_data from pointer
        Other_Structure* structure_data = (Other_Structure*)translated_data->Pointer;
        printf("You passed sructure with x, y, z: %d, %d, %d\n",
            structure_data->x, structure_data->y, structure_data->z);
        
    }
}


int main(){
    Other_Structure structure_data = {1,2,3};
    char* string_data = "Hi there!";

    WrappedArg arguments = {
        0, // type
        string_data
    };
    Our_Function((void*)&arguments);

    // OR

    arguments.Type = 1;
    arguments.Pointer = &structure_data;

    Our_Function((void*)&arguments);

    return 0;
}
AriaN
  • 329
  • 1
  • 8