Using a std::vector<char> as a variant

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::s开发者_开发技巧tring( 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

---

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.

---

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.

---

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.