如何从存储在void指针中的其他对象中访问对象的变量

如何解决如何从存储在void指针中的其他对象中访问对象的变量

我必须在一个类中创建一个动态数组并将另一个类的对象存储在该数组中。然后使用该数组访问其他类。总共有 3 个类要存储在同一个数组中。

但是当我尝试访问 var 时，它不允许我... (obj.arr[0].a;) 这个。我尝试了很多方法，但找不到任何解决方案。请帮忙。

代码：

class T1
{
public:
    int a = 1;
};

class T2
{
public:
    int a = 2;
};


class T
{
public:
    void *arr[];
};

int main()
{

    T obj;

    obj.arr[0] = new T1;
    obj.arr[1] = new T2;

    obj.arr[0].a;
}

解决方法

它不想让你，因为 void* 没有名为 a 的成员。您必须让编译器知道您想假装 void* 实际上是一个 T1*。

话虽如此，这是一种可怕的做法。 c++ 相对于 c 的一个优点是它提供了一种避免像这样强制多态的需要的方法。更好的方法是让所有类继承一个公共基类（而不是空指针，使用指向数组中该基类的指针）。如果虚拟方法满足您的需求，请使用它们，否则使用 dynamic_cast (https://en.cppreference.com/w/cpp/language/dynamic_cast) 检索整个对象。

如果您仍然坚持从 void* 中检索对象，请使用 static_cast 执行此操作，并三重检查您是否确实将对象置于该指针之下。

static_cast<T1*>(&obj.arr[0])->a;

您的 void*[] 的大小也未初始化，但我认为这只是为了简单起见？

,

要执行您正在尝试的操作，您需要对每个数组元素进行显式类型转换，例如：

class T1
{
public:
    int a = 1;
};

class T2
{
public:
    int a = 2;
};


class T
{
public:
    void **arr;
};

int main()
{
    T obj;

    obj.arr = new void*[2];
    obj.arr[0] = new T1;
    obj.arr[1] = new T2;

    static_cast<T1*>(obj.arr[0])->a;
    static_cast<T2*>(obj.arr[1])->a;

    ...

    delete static_cast<T1*>(obj.arr[0]);
    delete static_cast<T2*> obj.arr[1];
    delete[] obj.arr;
}

然而，这就引出了一个问题——你如何知道将每个元素转换为哪种类型？你可以这样做：

enum Ttype {typT1,typT2};

class TBase
{
    Ttype type;
    TBase(Ttype type) : type(type) {}
    virtual ~TBase() {}
};

class T1 : public TBase
{
public:
    int a = 1;
    T1() : TBase(typT1) {}
};

class T2 : public TBase
{
public:
    int a = 2;
    T2() : TBase(typT2) {}
};


class T
{
public:
    void **arr;
};

int main()
{
    T obj;

    obj.arr = new void*[2];
    obj.arr[0] = static_cast<TBase*>(new T1);
    obj.arr[1] = static_cast<TBase*>(new T2);

    for(int i = 0; i < 2; ++i) {
        TBase *tb = static_cast<TBase*>(obj.arr[i]);
        switch (tb->type) {
            case typT1:
                static_cast<T1*>(tb)->a;
                break;
            case typT2:
                static_cast<T2*>(tb)->a;
                break;
        }
    }

    ...

    delete static_cast<TBase*>(obj.arr[0]);
    delete static_cast<TBase*>(obj.arr[1]);
    delete[] obj.arr;
}

但这很丑陋，随着时间的推移，随着更多类的添加，维护起来会很乏味。

您应该将常见的 a 成员移动到基类中，并完全去掉 void*。无需强制转换，让多态为您服务：

class TBase
{
    int a;
    TBase(int a) : a(a) {}
    virtual ~TBase() {}
};

class T1 : public TBase
{
public:
    T1() : TBase(1) {}
};

class T2 : public TBase
{
public:
    T2() : TBase(2) {}
};


class T
{
public:
    TBase **arr;
};

int main()
{
    T obj;

    obj.arr = new TBase*[2];
    obj.arr[0] = new T1;
    obj.arr[1] = new T2;

    for(int i = 0; i < 2; ++i) {
        obj.arr[i]->a;
    }

    ...

    delete obj.arr[0];
    delete obj.arr[1];
    delete[] obj.arr;
}