Using a std::vector<char> as a variant - c++

Question

I want a simple variant with
minimal overhead
that can be passed to functions written in the C language
so I decided to use a std::vector like this
typedef std::vector<char> SimpleVariant;
SimpleVariant data;
(1) store a std::string
for(std::string::iterator it = str.begin(); it != str.end(); ++it)
{
data.push_back( *it );
}
data.push_back('\0');
(2) store a double
data.resize(64);
std::sprintf(&data[0], "%.*g", 20, val);
(3) get a string
std::string str = std::string( m_data.begin(), m_data.end() );
(4) get a double
double dbl = boost::lexical_cast<double>(&data[0]);
Is this a reasonable approach given my requirements? Is there lightweight variant that I can use instead of trying to reinvent the wheel?
I am aware of boost::variant and boost::any they are too heavyweight for my needs

Answer 1

that can be passed to functions written in the C language
No respectable variant in C++ is C-compatible, beyond passing a pointer to it as void* and providing functions that might manipulate it. C variants are guaranteed to be non-type-safe, whereas C++ variants have their types guaranteed. All you can do is store a type enumeration and a block of memory corresponding to the maximum size.
Also, boost::any isn't more heavyweight than a vector. You're just re-implementing it. In a less efficient way. And less safely.

Answer 2

Serializing to the textual representation of the data into dynamically allocated memory can hardly be considered minimal overhead. And then again, regarding the C functions, what exactly do you want to pass the variant to the C functions for, do you want just to pass the variant through? do you intend on using the data inside the C functions?
If you only want to pass the variant through C code (but not use it there), then consider using boost::variant or boost::any and passing void*, if you intend on using the data inside C, I would recommend to use a structure with a tag to identify the type and an array big enough to hold the data you want to store and then cast the values into that array.

Answer 3

You haven't really given much information about how the C interface to this works. So this suggestion may not be helpful. But let's assume you have a C interface that looks like this:
int GetAValue(void *data, int size); //Returns the type of data stored in the data pointer. Will not write past size.
void DoSomethingWithValue(int type, void *data, int size); //Gives data to C, to do something with. Does not modify it.
void ModifyValue(int type, void *data, int size); //Gives data to C, where it modifies it.
I would use a boost::variant as follows:
typedef boost::variant<int, double, std::string> MyVariant;
struct DoSomethingWithValueVisit : public boost::static_visitor<>
{
void operator()(int val)
{
DoSomethingWithValue(TYPE_INTEGER, &val, sizeof(int));
}
void operator()(double val)
{
DoSomethingWithValue(TYPE_DOUBLE, &val, sizeof(double));
}
void operator()(const std::string &val)
{
DoSomethingWithValue(TYPE_STRING, (void*)val.c_str(), val.size() + 1);
}
};
struct ModifyValueVisit : public boost::static_visitor<>
{
void operator()(int &val)
{
ModifyValue(TYPE_INTEGER, &val, sizeof(int));
}
void operator()(double &val)
{
ModifyValue(TYPE_DOUBLE, &val, sizeof(double));
}
void operator()(std::string &val)
{
char buffer[128];
strncpy(buffer, val.c_str(), 127);
ModifyValue(TYPE_STRING, buffer, 128);
val = buffer;
}
};
MyVariant GetAValueFromC()
{
char buffer[128];
int type = GetAValue(buffer, 128);
switch(type)
{
case TYPE_INTEGER:
return *reinterpret_cast<int*>(&buffer[0]);
case TYPE_DOUBLE:
return *reinterpret_cast<double*>(&buffer[0]);
case TYPE_STRING:
return std::string(buffer);
}
}
int main()
{
MyVariant value = GetAValueFromC();
//Non-modifying
boost::apply_visitor(DoSomethingWithValueVisit(), value);
//Modifying
boost::apply_visitor(ModifyValueVisit(), value);
}
Feel free to add more types to the variant as needed.