Question

我目前正在为C ++中的大表实现数据存储。该表需要能够为每个可变数量的列存储不同的数据类型。

定义每个列的类型和长度以及运行时。因此，我想，向量指针的向量将是正确的方法。但是，我无法弄清楚如何使用可变数据类型。

我看了How to get a vector of different vectors in C++，但没有动态解决方案。

我对任何其他解决方案持开放态度，我不一定需要向量，但该表应该在运行时重新调整大小。

看起来应该是这样的：

0  1  2  3    ...
-  -  -  -    -
1  a  0  1.3  ...
2  b  1  2.5  ...
3  c  0  1.5  ...
4  d  0  0.8  ...
5  e  1  1.2  ...
.. .. .. ...  ...

我有些人建议使用boost :: any但我对此有点不情愿（在效率方面），因为该表必须从磁盘加载大型数据包文件。

Answer 1

在boost中实现的any类将满足您的需求。

以下是如何在其网站上使用它的示例：

#include <vector>
#include <boost/any.hpp>

using boost::any_cast;
typedef std::vector<boost::any> many;

void append_int(many & values, int value)
{
    boost::any to_append = value;
    values.push_back(to_append);
}

void append_string(many & values, const std::string & value)
{
    values.push_back(value);
}

void append_char_ptr(many & values, const char * value)
{
    values.push_back(value);
}

void append_any(many & values, const boost::any & value)
{
    values.push_back(value);
}

void append_nothing(many & values)
{
    values.push_back(boost::any());
}

Answer 2

要在向量中存储不同的类型是不可能的，但如果存储没有类型的指针（void*），则可以将其重新键入任何所需的类型。如果您在运行时不知道您正在读什么类型，那么请使用指针void *和variable来构造struct以确定类型。

自从我使用C ++以来，所以示例可以只是伪C ++。

#include<vector>
#include<iostream>

void workWithCharArray(char* c);

typedef struct mytype {
    int type = 0;   // this defining default values is available since C++11
    void* var = nullptr;
} Mytype;

int main() {
    char* ptr = (char*)"Testing string";
    std::vector<Mytype> container;
    Mytype tostore;
    tostore.type = 1;
    tostore.var = (void*)ptr;

    container.append(tostore);

    switch (tostore.type) {
        case 1:
            workWithCharArray((char*)tostore.var);
            break;
        default:
            std::cerr << "Unknown type - Error handling";
    }

    return 0;
}

void workWithCharArray(char* c) {
    std::cout << c << std::endl;
}

Answer 3

如果你不能使用boost而不想重新实现boost::any，你可以使用void *作为穷人的任何容器。表级别为std::vector<void *>，每列（类型为T）为std::vector<T>。然后，您依次分配每个列，并将列的地址存储在初始std::vector<void *>。

中

如果在使用之前转换每列的值，它应该可以工作。根据您的要求，正确实现它可能或多或少变得简单，因为当您有原始指针时，您应该仔细实现析构函数，并在适当时复制移动构造函数和分配或声明它们被删除。但它是一个（穷人）提升替代品......

Answer 4

如果你需要一个存储不同数据类型的一维向量的二维向量，你可以为内向量创建一个抽象的，非模板化的基类，然后在外向量中存储指向该抽象基类的指针，如果要在抽象向量上调用成员函数，则使用多态。

class AbstractVector {
    ... // provide pure virtual interface here
}

template<class T>
class MyVector : public AbstractVector, public std::vector<T> { 
    ... /* provide implementation of pure virtual interface using 
           already available functionality from std::vector here */
}

在您的实现中，您可以存储指向基类AbstractVector（或unique_ptrs或shared_ptrs的指针，具体取决于您要执行的操作）：

std::vector<AbstractVector *> table;
MyVector<int> * columnOne = new MyVector<int>;
MyVector<float> * columnTwo = new MyVector<float>;
table.push_back(columnOne);
table.push_back(columnTwo);

矢量的变量类型向量

4 个答案: