Re: how to force blind cast from void* to struct*
On Nov 5, 8:42 pm, James Kanze <james.ka...@gmail.com> wrote:
On Nov 5, 3:49 pm, terminator <farid.mehr...@gmail.com> wrote:
On Nov 2, 12:20 pm, James Kanze <james.ka...@gmail.com>
wrote:> On Nov 1, 4:32 pm, terminator
<farid.mehr...@gmail.com> wrote:
On Nov 1, 1:10 am, andreyvul <andrey....@gmail.com> wrote:
a pointer is an intrinsic type on which modern compilers are
elegant in optimizing. I mean using static_cast must not
impose any overhead .
I'm not sure I understand. A static_cast isn't a no-op, and
compilers do generate executable code for it, when the semantics
require it. About the only cast which is really guaranteed to
be a no-op at execution time (and the standard doesn't actually
make any guarantee here either) is const_cast; on some machines,
even reinterpret_cast will sometimes require executable code.
static_casting pointers generates a temporary copy of the original
pointer if pointers are of irrelevant types with similar alignment
properties ,but that can be removed by the optimizer .
I'm having trouble understanding your sentence. The result of a
static_cast (of pointers) is an rvalue; if it is bound to a
reference, or used in any other context which requires an objet,
there will be a copy. Always.
But that doesn't have anything to do with what I was talking
about. A static_cast is not always a no-op; at times, it
requires the compiler to generate code (e.g. most often, adding
a constant to the pointer).
In the case of reinterpret_cast, on machines where all pointers
have the same representation, the reinterpret_cast will be a
no-op, almost certainly. For some pointers:
static_cast<T*>( p ) != reinterpret_cast<T*>( p )
its a matter of context ,the OP is not referencing(nor addressing) the
casted pointer ; so there is a chance for removal of the copy as I
wrote before.
BTW while I was looking for a proof that in this context either
operator has the same effect ,I discovered that I had been mislead
here.Look out plz:
On Nov 1, 1:10 am, andreyvul <andrey....@gmail.com> wrote:
g++ says a reinterpret cast from void* is disallowed; however, all I'm
trying to do is de-capsulate a void* argument that holds the pointer
to a class (and static_cast forces cast constructor)
any solutions?
also this pops up: 43: error: expected unqualified-id before 'return'
code:
includes: stdio.h, stdlib.h, time.h, pthread.h
struct:
template <typename T> struct mergesort_thread {
T* start;
T* end;
mergesort_thread(T* _start, T* _end) { start = _start; end = _end; }
static void *invoke(void *_this) {
pthread_t threads[2];
mergesort_thread<T> *child1, *child2;
T *mid, *shift, t;
T* start =
(reinterpret_cast< mergesort_thread<T> >(_this))->start;
T* end =(reinterpret_cast< mergesort_thread<T> >(_this))->end;
the template does not inherit from its type-parameter ,hence a pointer
to template('mergesort_thread<T>') is not implicitly castable to that
of its type-param('T').So the compiler`s complaign about casting is no
surpris.whatever the casting operator,the compiler will cry that it
cannot cast.The problem is in initializing from the result of the cast
operator.
regards,
FM.