矢量的变量类型向量

Question

I am currently implementing a data storage for a large table in C++. The table needs to be able to store different data type for each of a variable number of columns.

The type and the length of each column are defined and run-time. Because of this, I figured, a vector of pointer to vectors would be the right approach. I can however not figure out how to do this with variable data types.

I looked at How to get a vector of different vectors in C++ but there is not dynamic solution.

I am open to any other solutions, I don't necessarily need vectors, but the table should be re-sizable at run-time.

It should look something like this:

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  ...
.. .. .. ...  ...

I some people have suggested using boost::any but I am a bit reluctant of this (in terms of efficiency) because the table has to load large packet files from disk.

Answer 1

The any Class implemented in boost will do what you need.

Here is an example how to use it from their website:

#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

To store different types in vector is impossible, but if you store pointers without type ( void* ), then you can retype it to any type you want. If you don't know at runtime what type you are reading, then make struct containing pointer void* and variable to determine type.

It's while since I used C++ so example can be just pseudo 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

If you cannot use boost and do not want to re-implement boost::any you could use void * as the poor man's any container. The table level would be a std::vector<void *> and each column (of type T) would be a std::vector<T> . You then allocate each column in turn and store the address of the column in the initial std::vector<void *> .

Provided you cast the value of each column before using it it should work. Depending on your requirements it may be more or less simple to implement that correctly because as you have raw pointers you should implement carefully the destructors and if appropriate copy an move constructors and assignements or declare them deleted. But it is a (poor man's) boost alternative...

Answer 4

If you need a two-dimensional vector that stores one-dimensional vectors of different data types, you could create an abstract, non-templated base class for the inner vector and then store pointers to that abstract base class in the outer vector, utilising polymorphism if you want to call member functions on the abstract vectors.

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

In your implementation you can then store pointers to the base class AbstractVector (or unique_ptrs or shared_ptrs depending on what you want to do):

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