Question

template<typename T>
class ClassVariantVisitor : public boost::static_visitor<T>
{
public:
  T operator()(int& i) const {
    try
      {
        return boost::lexical_cast<T>(i);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
  }

  T operator()(double& d) const {
    try
      {
        return boost::lexical_cast<T>(d);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
  }

  // ...
};

As you can see, for each different type, the implementation code for operator() is exactly same. Is there a practical way that we can simplify the code?

Thank you

// Updated based on the comments //

template<typename T>
class ClassVariantVisitor : public boost::static_visitor<T>
{
public:
  T operator()(T& i) const {
    try
      {
        return boost::lexical_cast<T>(i);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
  }
};

Then the compiler(G++) will generate tons of errors.

///// Updated 2 based on comments from iammilind

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <boost/variant.hpp>
#include <boost/lexical_cast.hpp>

using namespace std;

typedef boost::variant<int, double, string> VarIntDoubleString;

// T is the result_type
template<typename T>
class ClassVariantVisitor : public boost::static_visitor<T>
{
public:
  template<typename U>
  T operator()(U& i) const {
    try
      {
        return boost::lexical_cast<T>(i);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
  }
};

int main(void)
{
  map<string, VarIntDoubleString> mapValuesThree;

  // store & retrieve char
  mapValuesThree["char_fieldI"] = VarIntDoubleString('c');
  char fieldI = boost::apply_visitor(ClassVariantVisitor<char>(), mapValuesThree["char_fieldI"]);
  cout << "fieldI: " << fieldI << endl;
}


~/Documents/C++/boost $ g++ -o p192f4 p192f4.cpp -Wall
~/Documents/C++/boost $ ./p192f4
terminate called after throwing an instance of 'char const*'
aborted
~/Documents/C++/boost $ g++ --version
g++ (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2

To iammilind:
As you can see, the compiler doesn’t generate any errors or warning during the compilation time.

// Updated 3 based on comments from Konstantin Oznobihin

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <boost/variant.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/utility/enable_if.hpp>

using namespace std;
template<typename T>
class ClassVariantVisitor : public boost::static_visitor<T>
{
public:
  typedef boost::mpl::vector<int, double, string> VarIntDoubleString;

  template <class U>
  typename boost::enable_if<
    typename boost::mpl::contains<VarIntDoubleString, U>::type, T>::type operator()(U &v) const 
  {
    try
      {
        return boost::lexical_cast<T>(v);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
  }
};

int main(void)
{
  map<string, ClassVariantVisitor::VarIntDoubleString> mapValuesThree;

  // store & retrieve double
  mapValuesThree["double_fieldJ"] = ClassVariantVisitor<double>::VarIntDoubleString(2.3456);
  double fieldJ = boost::apply_visitor(ClassVariantVisitor<double>(), mapValuesThree["double_fieldJ"]);
  cout << "fieldJ: " << fieldJ << endl;

}

I have no knowledge about boost::mpl and cannot make it work. Please refer to errors
May you let me how I can correct the code so that I use your idea and make it work.
Thank you

Answer 1

Use templatized operator() as suggested by iammilind but filter types with boost::mpl:

template<typename T>
class ClassVariantVisitor : public boost::static_visitor<T>
{
public:
  typedef boost::mpl::vector<int, double> source_types;

  template <class U>
  typename boost::enable_if<
    typename boost::mpl::contains<source_types, U>::type,
    T
  >::type operator()(U &v) const {
    try
      {
        return boost::lexical_cast<T>(v);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
};

UPDATE:
If you have boost::variant you can use it’s nested types sequence types instead of boost::mpl::vector and you don’t need to define the variant inside ClassVariantVisitor, here is an updated solution based on your code:

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <boost/variant.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/utility/enable_if.hpp>

using namespace std;

typedef boost::variant<int, double, string> VarIntDoubleString;

template<typename T>
class ClassVariantVisitor : public boost::static_visitor<T>
{
public:
  template <class U>
  typename boost::enable_if<
    typename boost::mpl::contains<VarIntDoubleString::types, U>::type, T>::type operator()(U &v) const 
  {
    try
      {
        return boost::lexical_cast<T>(v);
      } 
    catch ( boost::bad_lexical_cast& e)
      {
        throw e.what();
      }
  }
};

int main(void)
{
  map<string, VarIntDoubleString> mapValuesThree;

  // store & retrieve double
  mapValuesThree["double_fieldJ"] = VarIntDoubleString(2.3456);
  double fieldJ = boost::apply_visitor(ClassVariantVisitor<double>(), mapValuesThree["double_fieldJ"]);
  cout << "fieldJ: " << fieldJ << endl;
}