[33.8] Can I convert a pointer-to-function to a void*?

[EVOEx]

I came across this FAQ: [33] Pointers to member functions ..Updated!.., C++ FAQ Lite

One of the questions is
[33.8] Can I convert a pointer-to-function to a void*?
And they answer this with a "no, it's illegal". First my question: is it really illegal? I wouldn't have thought so. Let me explain why.

First let's consider C. We're free to convert any type of pointer to a void pointer without casting, and we're free to convert it back without any problems. So in C, this would definitely seem legal. So I would derive from that that on any architecture a pointer is a compatible type with a void pointer. That is, they are always the same size (or a void pointer is always the largest type, so it can hold any other type of pointer).

Now in C++ it was changed so you can no longer cast implicitly to or from void pointers. However, as far as I know, the underlying structure of the pointers still follow the same rules and thus it should still be legal to my understanding to cast a function pointer to a void pointer and back to a function pointer.
I believe that the implicit casting from/to void* was disabled because of classes, because it could result in very strange bugs if you would allow it, bugs that now require explicit casting.

Besides, I still see loads of APIs where you have to cast arguments to void*. pthread_create is an example. Even though it's a C API, it is assumed to be completely compatible with C++ as well, which it wouldn't be if you can not cast a pointer-to-function to a void*.

So, again: Can I "convert" (cast) a pointer-to-function to a void*? If not, could you explain what the C++ standard says that makes it illegal?


Thanks

[anon]

The FAQ goes on to say that it's illegal to cast even pointer-to-function to void*. Besides pthread_create (which I haven't used) seems to accept a void *(*start_routine)(void*) which is a different thing from void*. (I assume that through the void* argument you can smuggle in a struct that contains an object and a member function pointer?)

[EVOEx]

The FAQ goes on to say that it's illegal to cast even pointer-to-function to void*. Besides pthread_create (which I haven't used) seems to accept a void *(*start_routine)(void*) which is a different thing from void*. (I assume that through the void* argument you can smuggle in a struct that contains an object and a member function pointer?)

I know the FAQ says it's illegal, I just can't see why. And I'm talking about the argument to pthread_create. If you can cast a structure pointer to a void pointer, why not a function pointer? And the rest of my post still holds with why I disagree with the FAQ. But I might be missing something, that is basically my question: what am I missing?

[robwhit]

first thing you should do is separate the concepts of conversions and casts. casts are syntactic elements like (type) that perform a conversion. a conversion might or might not change the representation or value.

when you assign void* to another pointer type or back again, you don't need a cast, but a conversion does happen. the only type that is required to have the same representation as void* is char*, so a change to the representation converting to char* from void* or vice versa would not happen. conversions to/from other pointer types could have a change in representation.

also, 'compatible' is a term used in the C standard, and it's not how you're using it.

you can't convert pointers to functions to void* because void* is only for object (aka data) types. I think it was made like that because of harvard architecture processors, where code is on one bus and data is on another bus. the two buses could have different address widths.

posix and windows, afaik, guarantee that you can convert a pointer to function to void* and back.

[EVOEx]

So let me get this straight...
1. With pthread_create, the argument to the thread function, the only parameter you can legally specify is a character array, as only they are required to have the same width?
2. malloc can't be used in C++ except for character arrays. I know it's deprecated anyway, but it's even illegal? As "malloc(sizeof(SomeStruct))" won't work as the void pointer it returns may have a different width than the SomeStruct pointer?

If that's true, that means that so many APIs and applications are just wrong (okay, they are anyway). And so many APIs are useless in C++ if they are written for C.

And I won't even get started on mixing C++ with C. In fact, wouldn't it make it possible to write a function in C which does the void* to pointer-to-function conversion for you, and then link it with C++? Like:

typedef void (*func_ptr)();

void *convertFuncPtrToVoidPtr(func_ptr f)
{
  return f;
}

func_ptr convertVoidPtrToFuncPtr(void *v)
{
  return v;
}

And there, we can legally do what we couldn't with just C++.


So it still doesn't make much sense to me.


Thanks for your replies though.

[laserlight]

First let's consider C. We're free to convert any type of pointer to a void pointer without casting, and we're free to convert it back without any problems.

The 1999 edition of the C standard disagrees with you:

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

A pointer to a function of one type may be converted to a pointer to a function of another type and back again; the result shall compare equal to the original pointer. If a converted pointer is used to call a function whose type is not compatible with the pointed-to type, the behavior is undefined.

[anon]

I have been under the impression that casting objects to void* and back to the same type is OK. However, casting void* to pointer-to-member-function doesn't even compile (with GCC).

According to this understanding, something like the following should be OK (the member function pointer is not cast anywhere):

#include <iostream>
class Fred
{
public:
    int f(char x, float y) { std::cout << x << ' ' << y << '\n'; }
};

// FredMemFn points to a member of Fred that takes (char,float)
typedef  int (Fred::*FredMemFn)(char x, float y);

#define CALL_MEMBER_FN(object,ptrToMember)  ((object)->*(ptrToMember))

struct FredAndMethod
{
    Fred* fred;

    FredMemFn fun;
    float y;
    char x;
};

void fred_caller(void* data)
{
    FredAndMethod* fm = static_cast<FredAndMethod*>(data);
    CALL_MEMBER_FN(fm->fred, fm->fun)(fm->x, fm->y);
}

void callit(void (*f)(void*), void* data)
{
    f(data);
}

int main()
{
    Fred o;
    FredAndMethod fm = { &o, &Fred::f, 3.14f, 'x' };
    callit(fred_caller, &fm);             // okay
}

Of course, I might be wrong, but even Stroustrup in his technical FAQ shows casting void* to int*.

[EVOEx]

The 1999 edition of the C standard disagrees with you:

Actually, from what I see from that, the C standard agrees with me. Let's say we have two function types A and B (where A != B). We convert A to void*, then to B. We then call the dereference of this B-pointer. This is illegal. That's how I interpret the standard.
However the rest of your snippets say that if you compare A to void* and then back to A, then call the dereference of this A-pointer. This is apparently legal according to what you copy. So:

typedef void (*A)();
typedef int (*B)();

void test() {}

int main()
{
  void *tmp;
  A *a;
  B *b;

  a = &test;
  tmp = a;
  b = tmp;
  a = tmp;

  // Here, calling a is legal, but calling b is illegal
}

But the FAQ shows where a is called again, which would be legal in C, if I understand the snippets from the standard correctly.

So thanks for your answer, but my questions and confusions still stand.



@anon:
Thanks, but the following compiles just fine in GCC:

#include <stdio.h>

int main()
{
  void (*f)();
  void *tmp;

  tmp = f;
}

[laserlight]

Let's say we have two function types A and B (where A != B). We convert A to void*, then to B.

You cannot even legally convert A to void* since A is not "a pointer to any incomplete or object type".

[robwhit]

you haven't separated the concepts of casts and conversions correctly.

void *v = malloc(sizeof v); no conversion, no cast
int *i = malloc(sizeof i); conversion, no cast, possible change in representation
char *c = malloc(sizeof c); conversion (but no change in representation), no cast

int *i = (int*)malloc(sizeof i); conversion, cast, possible change in representation
char *c = (char*)malloc(sizeof c); conversion (but no change in representation), cast

1. With pthread_create, the argument to the thread function, the only parameter you can legally specify is a character array, as only they are required to have the same width?
For the void* parameter, you can pass any void*. in C, any pointer to object (not pointer to function) would get implicitly converted to a void. in C++, you'd have to explicitly convert it with a cast.

int *my_data;
pthread_t *pt;
pthread_arr_t *pa;
void *routine (void*);
pthread_create(pt, pa, &routine, my_data); /* in C */
pthread_create(pt, pa, &routine, (void*)my_data); /* in C++ */

2. malloc can't be used in C++ except for character arrays. I know it's deprecated anyway, but it's even illegal? As "malloc(sizeof(SomeStruct))" won't work as the void pointer it returns may have a different width than the SomeStruct pointer?
it would work if you casted the void* returned from malloc into the type of pointer you wanted. that would make a conversion happen, and it would be ok. (the conversion would be ok because malloc returns a pointer suitably aligned for any builtin type, and you can convert a pointer to another pointer type if the pointer's value is correctly aligned for the pointed-to type of the converted-to type)

[EVOEx]

Ahhh, I missed (at both robwhit's and laserlight's post) the point where an explicit distinction was made between function pointers and other pointers. It makes a lot more sense now.
And I do know the difference between conversion and cast but I'm talking about a cast because I'm talking about C++ here. And to get a conversion from one pointer type to another, you have to use a cast (with the exception of inheritance).

However, that means that while it's illegal to cast to void*, it's perfectly legal to cast it to void (*)()? Because that's probably what people want to cast to void* for (I don't even want to do it, when I don't fully understand something I just want to know for in the future): to be able to cast it back later and call it. From what I've seen it usually goes along with another parameter like function_type or num_args.

[Elysia]

pthread_create is flawed. Or at least it seems so to me.
It would need to convert that void* to a valid pointer type before calling it anyway, so why not take a correct type from the beginning? In C, there is no way to take an infinite number of function types in any reliable way to my knowledge.

[robwhit]

it's void* so you can pass a pointer to anything to it. if it was a narrower type, you'd have to have multiple pthread_create functions to have full coverage over all the possible argument types.

> In C, there is no way to take an infinite number of function types in any reliable way to my knowledge.
I don't know what that means.

@EVOEx remember the pointer to function isn't cast anywhere. the void* is cast inside *start_routine, if the function needs it.

but if you wanted a generic pointer to function, you could use any pointer to function type and cast it into the correct type before you call it. people use void(*)() or void(*)(void) because it's nondescript.

[bithub]

pthread_create is flawed. Or at least it seems so to me.
It would need to convert that void* to a valid pointer type before calling it anyway, so why not take a correct type from the beginning?

That void pointer is NOT the thread procedure function that gets called by the pthread implementation. That void pointer is just a user defined argument that can be NULL. Look at the third parameter instead of the fourth; you will see that it indeed takes the correct type of void *(*)(void*).

[Elysia]

Ah, I was confused by the Original Post in relation to the discussion. That makes sense, of course.