how to force blind cast from void* to struct*

[andreyvul]

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 Tstruct mergesort_threa d {
T* start;
T* end;
mergesort_threa d(T* _start, T* _end) { start = _start; end = _end; }
static void *invoke(void *_this) {
pthread_t threads[2];
mergesort_threa d<T*child1, *child2;
T *mid, *shift, t;
T* start = (reinterpret_ca st< mergesort_threa d<T(_this))->start;
T* end = (reinterpret_ca st< mergesort_threa d<T(_this))->end;
if (start >= end) return NULL; //recursed deep enough (1 element)
//recursively sort halves of the list
mid = (T*)(start + ((end - start) >1));
child1 = new mergesort_threa d<T>(start, mid);
pthread_create( &threads[0], NULL, mergesort_threa d<T>::invoke, (void
*)child1);
child2 = new mergesort_threa d<T>(mid + 1, end);
pthread_create( &threads[1], NULL, mergesort_threa d<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(th reads[0], NULL);
pthread_join(th reads[1], NULL);
for (;(start <= mid) && (mid + 1 <= end); start++) {
if (*start < *(mid + 1)) //sorted (current element belongs in 1st
half)
continue;
else { /* true inplace merge requires insersion-sort-like
* methods because a value from the second half is inserted to
* the current element */
//copy the first element in the second half to t
t = *(mid + 1);
//shift first half to the right
for (shift = mid; shift >= start; shift--)
*(shift + 1) = *shift;
//copy t to start
*start = t;
mid++;
}
}
}
43: return NULL;
};

[Victor Bazarov]

andreyvul 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?

Use 'static_cast'. That's what it's for (among some other things).

also this pops up: 43: error: expected unqualified-id before 'return'

It would seem your 'return' is outside of any function.

code:
includes: stdio.h, stdlib.h, time.h, pthread.h
struct:
template <typename Tstruct mergesort_threa d {
T* start;
T* end;
mergesort_threa d(T* _start, T* _end) { start = _start; end = _end; }
static void *invoke(void *_this) {
pthread_t threads[2];
mergesort_threa d<T*child1, *child2;
T *mid, *shift, t;
T* start = (reinterpret_ca st< mergesort_threa d<T(_this))->start;
T* end = (reinterpret_ca st< mergesort_threa d<T(_this))->end;
if (start >= end) return NULL; //recursed deep enough (1 element)
//recursively sort halves of the list
mid = (T*)(start + ((end - start) >1));
child1 = new mergesort_threa d<T>(start, mid);
pthread_create( &threads[0], NULL, mergesort_threa d<T>::invoke, (void
*)child1);
child2 = new mergesort_threa d<T>(mid + 1, end);
pthread_create( &threads[1], NULL, mergesort_threa d<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(th reads[0], NULL);
pthread_join(th reads[1], NULL);
for (;(start <= mid) && (mid + 1 <= end); start++) {
if (*start < *(mid + 1)) //sorted (current element belongs in 1st
half)
continue;
else { /* true inplace merge requires insersion-sort-like
* methods because a value from the second half is inserted to
* the current element */
//copy the first element in the second half to t
t = *(mid + 1);
//shift first half to the right
for (shift = mid; shift >= start; shift--)
*(shift + 1) = *shift;
//copy t to start
*start = t;
mid++;
}
}
}
43: return NULL;
};

--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[andreyvul]

On Oct 31, 6:16 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

andreyvul 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?

Use 'static_cast'. That's what it's for (among some other things).

also this pops up: 43: error: expected unqualified-id before 'return'

It would seem your 'return' is outside of any function.

code:
includes: stdio.h, stdlib.h, time.h, pthread.h
struct:
template <typename Tstruct mergesort_threa d {
T* start;
T* end;
mergesort_threa d(T* _start, T* _end) { start = _start; end = _end; }
static void *invoke(void *_this) {
pthread_t threads[2];
mergesort_threa d<T*child1, *child2;
T *mid, *shift, t;
T* start = (reinterpret_ca st< mergesort_threa d<T(_this))->start;
T* end = (reinterpret_ca st< mergesort_threa d<T(_this))->end;
if (start >= end) return NULL; //recursed deep enough (1 element)
//recursively sort halves of the list
mid = (T*)(start + ((end - start) >1));
child1 = new mergesort_threa d<T>(start, mid);
pthread_create( &threads[0], NULL, mergesort_threa d<T>::invoke, (void
*)child1);
child2 = new mergesort_threa d<T>(mid + 1, end);
pthread_create( &threads[1], NULL, mergesort_threa d<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(th reads[0], NULL);
pthread_join(th reads[1], NULL);
for (;(start <= mid) && (mid + 1 <= end); start++) {
if (*start < *(mid + 1)) //sorted (current element belongs in 1st
half)
continue;
else { /* true inplace merge requires insersion-sort-like
* methods because a value from the second half is inserted to
* the current element */
//copy the first element in the second half to t
t = *(mid + 1);
//shift first half to the right
for (shift = mid; shift >= start; shift--)
*(shift + 1) = *shift;
//copy t to start
*start = t;
mid++;
}
}
}
43: return NULL;
};

--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

I was using void* to encapsulate a struct, so I used reinterpret_cas t
because I know the actual type of the object that the void* is
referencing.
On a related note, do you of any c++ debuggers for linux? (gdb might
not work that easily with c++)

[Victor Bazarov]

andreyvul wrote:

[..]
I was using void* to encapsulate a struct, so I used reinterpret_cas t
because I know the actual type of the object that the void* is
referencing.

'reinterpret_ca st' is not for that. A pointer to an object can be
converted to 'void*' implicitly. You need 'static_cast' to get the
original pointer back.

On a related note, do you of any c++ debuggers for linux? (gdb might
not work that easily with c++)

I know that gdb worked just fine for me on Linux. Ask in the Linux
newsgroup, though. They may know more.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[James Kanze]

On Nov 1, 4:37 am, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

andreyvul wrote:

[..]
I was using void* to encapsulate a struct, so I used
reinterpret_cas t because I know the actual type of the
object that the void* is referencing.

'reinterpret_ca st' is not for that. A pointer to an object can be
converted to 'void*' implicitly. You need 'static_cast' to get the
original pointer back.

I'd use static_cast in this case, too, but according to the
standard, reinterpret_cas t is also legal (and should give the
same results).

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Nick Keighley]

On 31 Oct, 22:10, andreyvul <andrey....@gma il.comwrote:

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)

what's a "cast constructor"?

<snip>
--
Nick Keighley

[terminator]

On Nov 1, 1:10 am, andreyvul <andrey....@gma il.comwrote:

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 Tstruct mergesort_threa d {
T* start;
T* end;
mergesort_threa d(T* _start, T* _end) { start = _start; end = _end; }
static void *invoke(void *_this) {
pthread_t threads[2];
mergesort_threa d<T*child1, *child2;
T *mid, *shift, t;
T* start = (reinterpret_ca st< mergesort_threa d<T(_this))->start;
T* end = (reinterpret_ca st< mergesort_threa d<T(_this))->end;
if (start >= end) return NULL; //recursed deep enough (1 element)
//recursively sort halves of the list
mid = (T*)(start + ((end - start) >1));
child1 = new mergesort_threa d<T>(start, mid);
pthread_create( &threads[0], NULL, mergesort_threa d<T>::invoke, (void
*)child1);
child2 = new mergesort_threa d<T>(mid + 1, end);
pthread_create( &threads[1], NULL, mergesort_threa d<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(th reads[0], NULL);
pthread_join(th reads[1], NULL);
for (;(start <= mid) && (mid + 1 <= end); start++) {
if (*start < *(mid + 1)) //sorted (current element belongs in 1st
half)
continue;
else { /* true inplace merge requires insersion-sort-like
* methods because a value from the second half is inserted to
* the current element */
//copy the first element in the second half to t
t = *(mid + 1);
//shift first half to the right
for (shift = mid; shift >= start; shift--)
*(shift + 1) = *shift;
//copy t to start
*start = t;
mid++;
}
}
}
43: return NULL;

};- Hide quoted text -

a pointer is an intrinsic type on which modern compilers are elegant
in optimizing. I mean using static_cast must not impose any overhead .

regards,
FM.

[andreyvul]

Nick Keighley wrote:

On 31 Oct, 22:10, andreyvul <andrey....@gma il.comwrote:

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)

what's a "cast constructor"?

A copy constructor with an argument of an unrelated object type.
Example:
class foo1 {
...
};
class foo2 {
foo2(foo1& foo) {
...member... = foo.member...
...
}
};

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2007-11-01 18:06, andreyvul wrote:

Nick Keighley wrote:

>On 31 Oct, 22:10, andreyvul <andrey....@gma il.comwrote:

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)

what's a "cast constructor"?

A copy constructor with an argument of an unrelated object type.

The official name is converting constructor, if that matters.

--
Erik Wikström

[Nick Keighley]

On 1 Nov, 17:23, Erik Wikström <Erik-wikst...@telia. comwrote:

On 2007-11-01 18:06, andreyvul wrote:

Nick Keighleywrote:

On 31 Oct, 22:10, andreyvul <andrey....@gma il.comwrote:

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)

what's a "cast constructor"?

A copy constructor with an argument of an unrelated object type.

The official name is converting constructor, if that matters.

aren't those invoked even if there is no cast?

class A
{
public:
A();
A(B);
};

void g(A a)
{
}

void f()
{
A a;
B b;

g(b); // CTOR A(B) invoked here?
}
--
Nick Keighley