Question

我正在尝试将各种不同类型的数据存储在数组或向量中。到目前为止，我通过使用一个基类来实现这一点，该基类将作为指向每个对象的指针存储在向量中，然后键入强制转换以获取数据。这适用于int，但任何其他类型的数据都会引发访问冲突异常。

很抱歉，如果我的解释不是很好，这是我的代码，其中包含我希望有帮助的评论：

//Base class
class MenuProperty
{
private:
    std::string Name;

public:
    MenuProperty(std::string Name) : Name(Name) {};
    ~MenuProperty() {};

    std::string GetName();

};

//Typed class used to store data
template<class T>
class TMenuProperty : public MenuProperty
{
private:
    T Data;

public:
    TMenuProperty(std::string Name, T Data) : MenuProperty(Name), Data(Data) {};

    T GetData()
    {
       return this->Data;
    }
};

//Class with no type and data pointer to retrieve data
class cpMenuProperty : public MenuProperty
{
private:
    VOID* Data;

public:
    cpMenuProperty(std::string Name) : MenuProperty(Name) {};

    VOID* GetPointer()
    {
       return this->Data;
    }
};

希望有一些相似之处，这是我的测试代码：

int main()
{
    TMenuProperty<double> fP("Test2", 33.7354); //Create instance of property

    MenuProperty* fMP = &fP;                    //Make a pointer to the object

    cpMenuProperty* Test;                       //Make a pointer to the retrieving
                                                //object

    std::vector<MenuProperty*>              Vec;
    std::vector<MenuProperty*>::iterator    it;

    Vec.push_back(fMP);                         

    it = Vec.begin();

    Test = static_cast<cpMenuProperty*>(*it);   //Cast the first object in the list 
                                                //list to the same type as the
                                                //retrieveing object


    double Data = *(double*)Test->GetPointer(); //Dereference and access, this is
                                                //where the exception is thrown

    std::cout << Data;



    int Ret;
    std::cin >> Ret;
}

我可能在这里犯了一些巨大的错误，但是感谢你花时间阅读它到目前为止:)感谢任何帮助，也有建设性的批评！

Answer 1

您正在初始化堆栈上的TMenuProperty对象，然后将其转换为cpMenuProperty。永远不会为cpMenuProperty中的void * Data分配任何内存。 TMenuProperty和cpMenuProperty之间没有任何关系，除了它们来自同一个类。这种设计永远不会起作用。

摆脱所有的虚空*。那是在惹麻烦。
不要使用static_cast＆lt;＆gt;除非你100％知道你在做什么。使用dynamic_cast，它会告诉你转换是无效的（我猜你试过这个但是后来又回到了static_cast来强制代码至少编译:)）
为什么不一直使用TMenuProperty？这种方法应该有效。
对于你正在做的事情的其他方式，请看boost :: variant和boost :: any。
如果你是勇敢的并且真的知道你在做什么（没有冒犯，但我认为你没有资格获得这个），如果你需要包装的数据类型在内存布局方面足够统一，您可以使用适当的内存填充设置使代码工作，并以某种方式强制进行内存对齐。但是我无法提出任何场景，无论多么不可能，找到理由这样做。因此，从这篇文章中我可以看出，我只能建议删除cpMenuProperty并仅使用抽象基类/模板化派生类方法。

Answer 2

 #include<iostream>
 #include<vector>
 #include<iterator>
 #include<memory>
 class base {
 public:
 virtual void foo(){
      std::cout << "in base" << std::endl;
  }
 };

 class derived : public base {
 public:
 virtual void foo(){
      std::cout << "in derived" << std::endl;
   }
 };

 int main()
 {
    std::vector<std::unique_ptr<base>> vec;
    vec.emplace_back(new derived);
    static_cast<derived*>(vec[0].get())->foo();
    return 0;
  }

经典例子，使用现代实践。

在矢量中存储各种类型

2 个答案: