Casting to void* and typedefs in C++

Question

I'm wrapping a C++ library by writing a C interface. For this reason i created a C header file where most of the functions return/accept void* instead of C++ class pointers.

I know that is dangerous to cast from/to void* in C++, see Casting to void* and Back to Original_Data_Type*

Currently with inheritance i'm always casting to the base class of an object before assigning to void*

void* temp = static_cast<BaseClass*>(ptr)

and back

BaseClass* base = static_cast<BaseClass*>(voidPtr)
DerivedClass* derived = dynamic_cast<DerivedClass*>(base)

However using void* in a header files remove semantics and make complex functions hard to read. For example:

void myComplexFunc(void* index, void* data, void* somethingElse)

For mitigating this i wanted to use typedefs that even if they don't give any type safety at least they give to reader some insights. Compare the previous snippet with this one

extern "C" 
{
...
typedef void Index;
typedef void DBRecord;
typedef void DBResult;
void myComplexFunc(Index* index, DBRecord* data, DBResult* somethingElse)
...
}

Basically these typedefs act as a sort for documentation when multiple void* are used as parameters of a function (Keep in mind that i'm wrapping multiple C++ classes each with 10 methods, so there're lots of functions that thake a void* as first parameter).

For this reason i wanted to use to typedefs

extern "C" // In.h file (declaration)
{
typedef void Index;
...
Index* getIndex();
void modifyIndex(Index* index);
...
// In .cpp file (definition)
Index* getIndex() {
  DerivedCppIndex* derived = ...
  BaseCppIndex* base = static_cast<BaseCppIndex*>(derived)
  return base;
}
...
void modifyIndex(Index* index) {
  BaseCppIndex* base = static_cast<BaseCppIndex*>(index);
  DerivedCppIndex* derived = dynamic_cast<DerivedCppIndex*>(base);
  ...
}

Does the use of a typedef instead of void* causes any trouble regarding the issues of assignment to void*?

Is there any reason you're doing this? It seems like a super bad idea. — tadman, Mar 28 '16 at 17:32
I think (after writing my answer) that he doesn't want to expose his type hierarchy to the user; so while from his code `DerivedIndex` is convertible to `Index`, it won't work if all that's seen is `class Index; class DerivedIndex`. — Mark Nunberg, Mar 28 '16 at 17:34
sounds like an x-y problem, please provide some use case and background. — user3528438, Mar 28 '16 at 17:36
Answering the question literally, using `Index*` where index is `typedef`ed to `void` will be no different from using `void*`. Not sure what OP is asking actually. — SergeyA, Mar 28 '16 at 17:37
@SergeyA I added some info on my use case maybe now it's more clear my use case — Filippo Cucchetto, Mar 28 '16 at 18:37
This is just turning into an even darker shade of Wrong. Why, why are you doing this? If you have classes, use them. If you don't, why not? — tadman, Mar 28 '16 at 18:40
@tadman you cannot use class in a C interface (in a extern C block) — Filippo Cucchetto, Mar 28 '16 at 18:43
So is this C++ or is this C? If it's C++ that's not a concern. If it's C then you can't use any of this casting stuff in the first place. — tadman, Mar 28 '16 at 18:44
@user3528438 maybe you missed the first sentences in my update: i'm wrapping a C++ library for making callable from C. So my functions are declared in a extern "C" block (and that's the reason why i'm using void* for passing C++ classes to C). — Filippo Cucchetto, Mar 28 '16 at 18:46
@tadman the declarations are in a .h within a extern "C" block. The definitions are in a .cpp file — Filippo Cucchetto, Mar 28 '16 at 18:47
@tadman the C user doesn't see the definitions. I needs only the .h file plus the .so shared library. So he doesn't see any casting.. — Filippo Cucchetto, Mar 28 '16 at 18:49

score 2 · Accepted Answer · answered Mar 28 '16 at 17:28

2

It shouldn't cause any trouble, but it will only give API users a false sense of security (as any arbitrary pointer will also work). There's nothing to prevent the compiler from complaining if you do something like:

int i;
// ....
modifyIndex(&i);

So while you won't have any problems, you won't have any compile-time checks and enforcements either.

Do note that you have the choice of simply declaring the class without actually defining it.

The proper way to solve the void-pointer "problem" (and it's not really a problem, it's just an aspect of C (and thus C++) which may make code difficult to maintain without proper care/documentation) is to somehow expose Index as an opaque type; e.g.

// index.h
class Index;
// ...
void modifyIndex(Index *i);

answered Mar 28 '16 at 17:28

Mark Nunberg

3,551
15
18

I agree with you but my use case is wrapping a C library so i cannot use class in my public header file (and that's the reason of using void*) – Filippo Cucchetto Mar 28 '16 at 18:41
You can still make a dummy struct when running under C, for example: `#ifndef __cplusplus typedef struct IndexCDummy Index`. I've used this approach in the past - it ensures user type safety. `IndexCDummy` in this case isn't ever defined anywhere, but it does make the compiler aware of this typed opaque pointer. I'd put this in my answer, but it would make the answer substantially different from the way it stands – Mark Nunberg Mar 28 '16 at 18:56

score 0 · Answer 2 · answered Mar 28 '16 at 17:55

0

Creating a typedef for void is a bit awkward. More common practice is to define void* as IndexHandle and force clients of your code to read or pass as a parameter a value of the opaque handle type. All casting should take place inside of your code.

answered Mar 28 '16 at 17:55

jszpilewski

1,632
1
21
19

Casting to void* and typedefs in C++

2 Answers2