我的程序需要使用void*来在动态调用的情况下传输数据或对象,以便它可以引用任意类型的数据,甚至是原始类型的数据。然而,我最近发现,在具有多个基类的类的情况下,向下强制转换这些void*的过程失败,甚至在调用这些向下强制转换的指针上的方法后,即使内存地址看起来是正确的,也会导致程序崩溃。崩溃发生在访问"vtable“的过程中。
所以我创建了一个小的测试案例,环境是Mac上的gcc 4.2:
class Shape {
public:
virtual int w() = 0;
virtual int h() = 0;
};
class Square : public S
我写了越来越多的C应用程序,现在我想知道一些关于类型转换的东西。在C++中,动态类型转换是一个非常昂贵的操作(例如向下转换),但我甚至不知道静态类型的操作。
在C语言中,我不得不这样写:
assert ( p ); /* p is void* */
int v = *(int*)p;
它是«C动态转换»吗?它和C++的static_cast<int*>(p)很像吗?要花多少钱?
提前谢谢。
我一直在努力理解C++中的类型铸造。在下面的代码中,B类是A类的子类,它们都共享多态关系。
#include <iostream>
using namespace std;
class A{
int a;
public:
virtual void sayhello() {cout<<"Hello from A"<<endl;}
};
class B:public A{
int b;
public:
void sayhello(){cout<<"Hello fr
在传统的C中,你可以这样做:
int i = 48;
char c = (char)i;
//Now c holds the value of 48.
//(Of course if i > 255 then c will not hold the same value as i).
哪种c++转换方法(static_cast、reinterpret_cast)适合完成这项工作?
当使用使用C风格继承的casts时(利用C-结构的标准布局),比如,我们通常使用C风格的类型转换来向下转换:
struct base_object
{
int x;
int y;
int z;
};
struct derived_object
{
base_object base;
int foo;
int bar;
};
void func(base_object* b)
{
derived_object* d = (derived_object*) b; /* Downcast */
}
但是,如果我们正在编写使用这样的C-API
假设我们有这个密码
class A {
public:
A() : x(1) {}
virtual ~A() {}
int x;
};
class B {
public:
B() : y(2) {}
virtual ~B() {}
void g()
{
cout << "B::" << y << endl;
}
int y;
};
class C : private A, private B {
public:
void f()
例如:
class Base1 {};
class Base2 {};
class Derived: publid Base1, public Base2 {};
// object is stored on a void* slot
void* void_slot = new Derived();
// ... many decades after ...
//object is fetched from the void* slot
Base2* obj = (Base2*) void_slot;
obj->some_base2_method();
我认为这可能不安全。dyna
当我编译并运行这段代码时:
#include <iostream>
using namespace std;
class Base
{
public:
virtual void doSomething()
{
cout << endl << "hi this is base";
}
};
class DerivedA : public Base
{
public:
void doSomething()
{
cout << endl &l
我是C++的初学者,我在理解一些代码时遇到了问题。
我有一个练习要做,写一个返回int大小的函数,并且不使用sizeof()和reinterpret_cast。有人给了我解决方案,但我不明白它是如何工作的。你能帮我理解一下吗?代码如下:
int intSize() {
int intArray[10];
int * intPtr1;
int * intPtr2;
intPtr1 = &intArray[1];
intPtr2 = &intArray[2];
//Why cast int pointer to void pointer?
void*
可能重复:
这段代码在C中运行良好,但在编译为C++程序时会出现编译错误。
#include<stdio.h>
#include<stdlib.h>
int main(){
int (*b)[10];
b = calloc(20, sizeof(int));
return 0;
}
C++编译中的错误是:
test.cpp: In function ‘int main()’:
test.cpp:9:28: error: invalid conversion from ‘void*’ to ‘int (*)[10]’ [-fpermiss
我有一个A类的对象,我想在自定义堆栈对象上分配它。为此,我只需将堆栈指针移动到与对象大小相同的字节数,并返回其先前的值:
class A : public B {}; //B is from a precompiled library
class stack {
public:
stack(void): _top(&_storage[0]) {}
template <typename T>
inline T* push(void) {
T* ptr = static_cast<T*>(_top);
_
在什么情况下,可以使用reinterpret_cast从实际上是派生实例指针的基指针进行强制转换?(通过多态性)。
如果继承是多态的,则静态类型转换不起作用。
我考虑了这个微不足道的场景:
class A
{
public:
virtual void Hello()
{
cout<<" A ";
}
virtual int GetType() { return 1; }
};
class B: public A
{
public:
void Hello()
{
cout<<
这是一个有点复杂的问题,所以我将尽我所能解释发生了什么。如果我遗漏了什么,请告诉我,我可以澄清。
我们有一个回调系统,一方面一个模块或应用程序提供一个“服务”,客户端可以使用这个服务执行操作(基本上是一个非常初级的IPC )。为了便于将来参考,假设我们有如下定义:
typedef int (*callback)(void*); // This is NOT in our code, but makes explaining easier.
installCallback(string serviceName, callback cb); // Really handled by a prop