Re: reference to pointer
Ralf Goertz wrote:
Jonathan Lee wrote:
Hi Ralf,
Hi Jonathan,
void foo(someClass* s) {
someOtherClass* &pr(reinterpret_cast<someOtherClass*>(s->ptr));
/* ... */
}
The result of reinterpret_cast<>() is an rvalue. It can't be
referenced, or used to initialize a reference. That's more or less
what the error message is saying.
Okay.
Note also that reinterpret_cast<>() is pretty much an all around bad
idea. Especially for circumventing the type system, as you seem to
have done. Personally, I would have define a constructor for
someOtherClass() that accepted your char*, then create an instance of
your object and act on that. Copying it back out if need be. If your
code truly runs "a zillion" times (heh) this shouldn't be costly to
do.
I don't have a choice. foo() is a "User Defined Function" for our
MySQL server. someClass (actually called initid) is a structure that
is used to communicate with the server. The manual says:
char *ptr
A pointer that the function can use for its own purposes. For
example, functions can use initid->ptr to communicate allocated
memory among themselves. xxx_init() should allocate the memory and
assign it to this pointer: initid->ptr = allocated_memory; In xxx()
[my function foo] and xxx_deinit(), refer to initid->ptr to use or
deallocate the memory.
As long as you ensure that ptr actually points to an object of type
someOtherClass, then your reinterpret_cast is safe.
But I would submit a bug-report to MySQL that ptr should have the type
'void*' as that matches better with its intended purpose. (And then you
would be able to use static_cast, which is less of a red-flag.)
As for the creation of variables, I would expect (nearly) identical code
for both of these:
void foo(initid* s) {
someOtherClass* ptr(reinterpret_cast<someOtherClass*>(s->ptr));
/* ... */
}
and
void foo(initid* s) {
someOtherClass& ref(*reinterpret_cast<someOtherClass*>(s->ptr));
/* ... */
}
<snip>
They probably cause much less harm than newing an deleting objects.
Local variables (stack allocated) are several orders of magnitude faster
to create than dynamically allocating the same.
But still if I can get away with aliases (to avoid the repeated
casts), I'd like to do so.
Either an alias (reference) or a correctly typed pointer will work here.
It is likely that the reinterpret_cast will result in zero assembly
instructions.
Ralf
Bart v Ingen Schenau
--
a.c.l.l.c-c++ FAQ: http://www.comeaucomputing.com/learn/faq
c.l.c FAQ: http://c-faq.com/
c.l.c++ FAQ: http://www.parashift.com/c++-faq-lite/