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

【问题标题】：How to access variable of an object from within an other object stored in void pointer如何从存储在 void 指针中的其他对象中访问对象的变量
【发布时间】：2021-01-25 17:01:33
【问题描述】：

我必须在一个类中创建一个动态数组并将另一个类的对象存储在该数组中。然后使用数组访问其他类。共有 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*的。一旦你做了那个转换，你就不再知道它指向什么了。看起来您可能需要 std::variant 或 std::any。
我必须在自定义类中创建数组。我不能使用系统构建的类，如 std::variant 或 std::any 你的回答很受欢迎。
“我不能使用系统构建的类...” - 因为？我的意思是，我不能，因为我的组织还没有使用符合 C++17 的工具链，并且不允许使用 boost。但是，出于好奇，你为什么不能呢？
@muhammadomerirfan 在这种情况下，您需要建立自己的标记联合（基本上是std::variant）。

标签： c++ class void-pointers

【解决方案1】：

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

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

如果您仍然坚持从void* 检索对象，请使用static_cast 执行此操作，并再次检查您是否确实将对象放在该指针下。

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

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

【讨论】：

Should I use static_cast or reinterpret_cast when casting a void* to whatever

【解决方案2】：

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

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;
}

【讨论】：