可变类型向量的向量 我现在正在为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，但我有点不愿意这样做（在效率方面），因为表必须从磁盘加载大型数据包文件。

在boost中实现的类将满足您的需要

以下是如何从他们的网站使用它的示例：

#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());
}

#包括
#包括
使用boost:：any_cast；
typedef std：：向量多；
void append_int（多个&值，int值）
{
boost:：any to_append=值；
值。向后推_（以追加_）；
}
void append_字符串（多个和值，常量std:：字符串和值）
{
值。推回（值）；
}
void append_char_ptr（多个&value，常量char*value）
{
值。推回（值）；
}
void append_any（多个&value，常量boost:：any&value）
{
值。推回（值）；
}
void append_nothing（多个值和多个值）
{
value.push_back（boost:：any（））；
}

在vector中存储不同类型是不可能的，但如果存储的指针没有类型（

void*

），则可以将其重新键入所需的任何类型。若您在运行时不知道正在读取的类型，那个么将包含指针void*和变量的结构设置为确定类型

<>我使用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;
}

#包括
#包括
使用字符的无效工作（字符*c）；
类型定义结构mytype{
int type=0；//此定义默认值自C++11起可用
void*var=nullptr；
}Mytype；
int main（）{
char*ptr=（char*）“测试字符串”；
载体容器；
Mytype tostore；
tostore.type=1；
tostore.var=（void*）ptr；
container.append（tostore）；
开关（tostore.type）{
案例1：
将chararray（（char*）转换为store.var）；
打破
违约：
std:：cerr如果您不能使用boost并且不想重新实现
boost:：any
您可以使用
void*
作为穷人的任意容器。表级别将是一个
std:：vector
和每个列（类型为T）将是一个
std:：vector
。然后依次分配每个列，并将列的地址存储在初始
std:：vector
中

如果您在使用前强制转换每一列的值，它应该可以工作。根据您的要求，正确实现它可能或多或少比较简单，因为您有原始指针，因此应该小心地实现析构函数，如果合适的话，复制移动构造函数和赋值或声明将其删除。但这是一个（穷人的）boost alternative…
如果需要存储不同数据类型的一维向量的二维向量，可以为内部向量创建一个抽象的非模板基类，然后在外部向量中存储指向该抽象基类的指针，如果要调用abstrac上的成员函数，可以使用多态性t向量

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 */
}

你想在向量中使用任意类型的数据吗？它必须是基于单元格或列的任意类型？请添加一个最小的伪代码示例，说明你想要实现什么…表必须是基于列的任意类型。在每列中，数据类型保持不变。我在最初的问题中添加了一个图表，你不需要比如boost：：任何“在效率方面”，与什么相比？您是否实际测量到它比，比如说，
void*
s变成一个巨大的字符[]慢得令人无法接受？到目前为止，我还没有衡量过这一点。我正在尝试找出我有哪些选项。如果我必须在一个整数列中对10000个以上的条目求和，那么将它们存储为字符串并在每次需要访问它们时强制转换它们似乎是非常低效的。我也遇到了这个问题，但是，我想知道这有多高效？我必须阅读la从磁盘上填充数据包，以填充表。这些文件可以在一个GB的大小。任何不是容器。@ Pel333如果你关心效率，考虑将所有数据存储为字符串，然后在必要时进行转换的可能性。有可能是<代码> Booost：：任何< /C> >将是优越的。@ LexNeasraceSin轨道参见：任何类{哈，我的错误；我认为这将是一个类模板，但这没有意义。：）我确实可以访问boost，我正在我的程序的其他部分使用它。但我担心，在处理大型数据集（我必须在其上执行数字运算）时，将所有数据转换为字符串会有点效率低下。
std::vector<AbstractVector *> table;
MyVector<int> * columnOne = new MyVector<int>;
MyVector<float> * columnTwo = new MyVector<float>;
table.push_back(columnOne);
table.push_back(columnTwo);