如何强制盲目施放从void *到struct * [英] how to force blind cast from void* to struct*
问题描述
g ++表示不允许对void *进行重新解释;但是，所有我想要做的是b $ b解包一个void *参数，该指针将指针
保存到一个类（和static_cast强制转换构造函数）
任何解决方案？
也弹出：43：错误：预期不合格-id'返回''
代码：
包括：stdio.h，stdlib.h，time.h，pthread.h
struct：
template< typename Tstruct 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;
if（start> = end）返回NULL; //足够深的递归（1个元素）
//递归排序列表的一半
mid =（T *）（start +（（end - start）> 1））;
child1 = new mergesort_thread< T>（start，mid）;
pthread_create（& threads [0]，NULL，mergesort_thread< T> ::调用，（void
*）child1）;
child2 = new mergesort_thread< T>（mid + 1，end）;
pthread_create（ & threads [1]，NULL，mergesort_thread< T> :: invoke，（void
*）child2）;
delete child1;
删除child2;
pthread_join（threads [0]，NULL）;
pthread_join（threads [1]，NULL）;
for（ ;（开始< = mid）&&（mid + 1< = end）;开始++）{
if（* start< *（mid + 1））// sorted（当前元素属于第一个
一半）
继续;
else {/ * true inplace merge需要insersion-sort-like
*方法，因为下半部分的值被插入到
*当前元素* /
//将下半场的第一个元素复制到t
t = *（mid + 1）;
//上半场换班在右边
for（shift = mid; shift> = start; shift--）
*（shift + 1）= * shift;
//复制t开始
* start = t;
mid ++;
}
}
}
43：返回NULL;
};
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_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;
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_thread<T>(start, mid);
pthread_create(&threads[0], NULL, mergesort_thread<T>::invoke, (void
*)child1);
child2 = new mergesort_thread<T>(mid + 1, end);
pthread_create(&threads[1], NULL, mergesort_thread<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(threads[0], NULL);
pthread_join(threads[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;
};
推荐答案
andreyvul写道：
andreyvul wrote:
g ++说不允许对void *进行重新解释;但是，所有我想要做的是b $ b解包一个void *参数，该指针将指针
保存到一个类（和static_cast强制转换构造函数）
任何解决方案？
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?
使用''static_cast''。这就是它的原因（在其他一些事情中）。
Use ''static_cast''. That''s what it''s for (among some other things).
这也会弹出：43：错误：在''返回之前预期不合格的id ''
also this pops up: 43: error: expected unqualified-id before ''return''
看起来你的''返回''不属于任何函数。
It would seem your ''return'' is outside of any function.
code ：
包括：stdio.h，stdlib.h，time.h，pthread.h
struct：
template< typename Tstruct 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;
if（start> = end）返回NULL; //足够深的递归（1个元素）
//递归排序列表的一半
mid =（T *）（start +（（end - start）> 1））;
child1 = new mergesort_thread< T>（start，mid）;
pthread_create（& threads [0]，NULL，mergesort_thread< T> ::调用，（void
*）child1）;
child2 = new mergesort_thread< T>（mid + 1，end）;
pthread_create（ & threads [1]，NULL，mergesort_thread< T> :: invoke，（void
*）child2）;
delete child1;
删除child2;
pthread_join（threads [0]，NULL）;
pthread_join（threads [1]，NULL）;
for（ ;（开始< = mid）&&（mid + 1< = end）;开始++）{
if（* start< *（mid + 1））// sorted（当前元素属于第一个
一半）
继续;
else {/ * true inplace merge需要insersion-sort-like
*方法，因为下半部分的值被插入到
*当前元素* /
//将下半场的第一个元素复制到t
t = *（mid + 1）;
//上半场换班在右边
for（shift = mid; shift> = start; shift--）
*（shift + 1）= * shift;
//复制t开始
* start = t;
mid ++;
}
}
}
43：返回NULL;
};
code:
includes: stdio.h, stdlib.h, time.h, pthread.h
struct:
template <typename Tstruct 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;
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_thread<T>(start, mid);
pthread_create(&threads[0], NULL, mergesort_thread<T>::invoke, (void
*)child1);
child2 = new mergesort_thread<T>(mid + 1, end);
pthread_create(&threads[1], NULL, mergesort_thread<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(threads[0], NULL);
pthread_join(threads[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;
};
-
请在通过电子邮件回复时删除资金''A'
我请不要回复最热门的回复，请不要问
--
Please remove capital ''A''s when replying by e-mail
I do not respond to top-posted replies, please don''t ask
10月31日下午6:16，Victor Bazarov < v.Abaza ... @ comAcast.netwrote：
On Oct 31, 6:16 pm, "Victor Bazarov" <v.Abaza...@comAcast.netwrote:
andreyvul写道：
andreyvul wrote:
g ++说不允许从空*重新诠释;但是，所有我想要做的是b $ b解包一个void *参数，该指针将指针
保存到一个类（和static_cast强制转换构造函数）
任何解决方案？
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?
使用''static_cast''。这就是它的原因（在其他一些事情中）。
Use ''static_cast''. That''s what it''s for (among some other things).
这也会弹出：43：错误：在''返回之前预期不合格的id ''
also this pops up: 43: error: expected unqualified-id before ''return''
看起来你的''返回''不属于任何函数。
It would seem your ''return'' is outside of any function.
code ：
包括：stdio.h，stdlib.h，time.h，pthread.h
struct：
template< typename Tstruct 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;
if（start> = end）返回NULL; //足够深的递归（1个元素）
//递归排序列表的一半
mid =（T *）（start +（（end - start）> 1））;
child1 = new mergesort_thread< T>（start，mid）;
pthread_create（& threads [0]，NULL，mergesort_thread< T> ::调用，（void
*）child1）;
child2 = new mergesort_thread< T>（mid + 1，end）;
pthread_create（ & threads [1]，NULL，mergesort_thread< T> :: invoke，（void
*）child2）;
delete child1;
删除child2;
pthread_join（threads [0]，NULL）;
pthread_join（threads [1]，NULL）;
for（ ;（开始< = mid）&&（mid + 1< = end）;开始++）{
if（* start< *（mid + 1））// sorted（当前元素属于第一个
一半）
继续;
else {/ * true inplace merge需要insersion-sort-like
*方法，因为下半部分的值被插入到
* th当前元素* /
//将下半年的第一个元素复制到t
t = *（mid + 1）;
/ /将上半部分向右移动
for（shift = mid; shift> = start; shift--）
*（shift + 1）= * shift;
//复制t开始
* start = t;
mid ++;
}
}
}
43：返回NULL;
};
code:
includes: stdio.h, stdlib.h, time.h, pthread.h
struct:
template <typename Tstruct 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;
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_thread<T>(start, mid);
pthread_create(&threads[0], NULL, mergesort_thread<T>::invoke, (void
*)child1);
child2 = new mergesort_thread<T>(mid + 1, end);
pthread_create(&threads[1], NULL, mergesort_thread<T>::invoke, (void
*)child2);
delete child1;
delete child2;
pthread_join(threads[0], NULL);
pthread_join(threads[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;
};
-
请在通过电子邮件回复时删除资金''A'
我不回复热门回复，请不要问
--
Please remove capital ''A''s when replying by e-mail
I do not respond to top-posted replies, please don''t ask
我使用void *来封装结构，所以我使用了reinterpret_cast
，因为我知道void *是
引用的对象的实际类型。
在相关的说明中，你是否有任何Linux的c ++调试器？ （gdb可能
不能轻易用c ++工作）
I was using void* to encapsulate a struct, so I used reinterpret_cast
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++)
andreyvul写道：
andreyvul wrote:
[..]
我使用void *来封装结构，所以我使用了reinterpret_cast
，因为我知道对象的实际类型void *是
引用。
[..]
I was using void* to encapsulate a struct, so I used reinterpret_cast
because I know the actual type of the object that the void* is
referencing.
''reinterpret_cast''不适用于此。指向对象的指针可以隐式地转换为''void *''。你需要''static_cast''才能获得
原始指针。
''reinterpret_cast'' 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.
在相关的说明中，你是否有任何c ++调试器Linux呢？ （gdb可能
不能用c ++轻松工作）
On a related note, do you of any c++ debuggers for linux? (gdb might
not work that easily with c++)
我知道gdb在Linux上运行得很好。但是，在Linux
新闻组中询问。他们可能知道的更多。
V
-
请在回复e-时删除资金'A'邮件
我没有回复最热门的回复，请不要问
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
这篇关于如何强制盲目施放从void *到struct *的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
