C++ (Qt)
#include <iostream>
#include <variant.h>
#include <string>
#include <boost/optional.hpp>
 
typedef variant<float, double, int, std::string> variant_t;
 
int main()
{
    variant_visitor<boost::optional<double> (variant_t)> is_numeric;
    is_numeric.reg<double>([](variant_t v) { return v.get<double>(); });
    is_numeric.reg<int>([](variant_t v) { return v.get<int>(); });
    is_numeric.reg<float>([](variant_t v) { return v.get<float>(); });
 
    variant_visitor<boost::optional<std::string> (variant_t)> is_string;
    is_string.reg<std::string>([](variant_t v) { return v.get<std::string>(); });
 
    variant_t v = 123.676;
    variant_t v2 = std::string("abc");
 
    if (is_numeric(v))
        std::cout << *is_numeric(v) << std::endl;
 
    if (is_string(v2))
        std::cout << *is_string(v2) << std::endl;
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <string>
#include <boost/optional.hpp>
#include <boost/variant.hpp>
 
typedef boost::variant<float, double, int, std::string> variant_t;
 
struct is_numeric : public boost::static_visitor<boost::optional<double>>
{
    result_type operator()(float v) const { return v; }
    result_type operator()(double v) const { return v; }
    result_type operator()(int v) const { return v; }
 
    template <class R>
    result_type operator()(R) const { return result_type(); }
};
 
 
struct is_string : public boost::static_visitor<boost::optional<std::string>>
{
    result_type operator()(const std::string & v) const { return v; }
 
    template <class R>
    result_type operator()(R) const { return result_type(); }
};
 
int main()
{
    variant_t v = 123;
 
    if (boost::apply_visitor(is_numeric(), v))
        std::cout << *boost::apply_visitor(is_numeric(), v) << std::endl;
 
    if (boost::apply_visitor(is_string(), v))
        std::cout << *boost::apply_visitor(is_string(), v) << std::endl;
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <string>
#include <vector>
 
struct MyStruct {
	MyStruct( int val = 0 ) : mUseText(false), mVal(val) {}
	MyStruct( const char * str ) : mUseText(true), mStr(str) {}
 
	bool operator < ( const MyStruct & sec ) const
	{
		if (mUseText || sec.mUseText) return false;	// wrong
		return mVal < sec.mVal;
	}
 
// data
	bool mUseText;
	union {
		int mVal;
		const char * mStr;
	};
};
 
int main( void )
{
	std::vector <MyStruct> vec;
	vec.push_back(MyStruct("str1"));
	vec.push_back(MyStruct(5));
	vec.push_back(MyStruct(2));
	vec.push_back(MyStruct("str2"));
	vec.push_back(MyStruct(1));
	vec.push_back(MyStruct("str3"));
 
	std::sort(vec.begin(), vec.end());
 
	for (size_t i = 0; i < vec.size(); ++i)
		if (vec[i].mUseText)
			std::cout << vec[i].mStr << std::endl;
		else
			std::cout << vec[i].mVal << std::endl;
 
	return 0;
}
 

C++ (Qt)
typedef boost::variant<float, double, int, long, short, std::string> variant_t;
 
struct numeric : public boost::static_visitor<boost::optional<double>>
{
    template <class T>
    result_type operator()(T v) const
    {
        return std::is_arithmetic<T>::value ? v : result_type();
    }
 
    result_type operator()(const std::string & s) const
    {
        try {
            return std::stod(s);
        } catch (...) {
            return result_type();
        }
    }
};
 

C++ (Qt)
void Test( const ClassNum & src )
{
  double d = src;
  short s = src;      // неясно, а если src не влезет в short?
  std:::string s = src;
//  long long l = src; // а этого типа нет для ClassNum
}  
 

C++ (Qt)
void Test( const ClassNum & src )
{
  double d = get<double>( src );
  short s = get<short>( src );      // Если не будет влазить в short - обрежется, а можно и исключение бросать об этом
  std::string str = get<std::string>( src );
  long long l = get<long long>( src ); // И не важно, что этого типа нет в варианте
 
  // или второй вариант get
  double d;
  get( d, src );
  short s;
  get( s, src );
  long long l;
  get( l, src );
} 
 

C++ (Qt)
typedef boost::variant<short, int, long, float, double, std::string>	var_t;
 
template<class T>
struct numeric : public boost::static_visitor<T>
{
	template<class V>
	T operator()( V val ) const
	{
		return std::is_arithmetic<V>::value ? val : std::numeric_limits<T>::max();
	}
 
	T operator()( const std::string &val ) const
	{
		try { return boost::lexical_cast<T>( val ); } catch(...) {}
		return std::numeric_limits<T>::max();
	}
};
 
struct literal : public boost::static_visitor<std::string>
{
	template<class V>
	std::string operator()( V val ) const
	{
		return boost::lexical_cast<std::string>( val );
	}
};
 
template<class T>
T get( var_t v )
{
	static_assert( std::is_arithmetic<T>::value, "Shit type T" );
	return boost::apply_visitor( numeric<T>(), v );
}
 
template<>
std::string get<std::string>( var_t v )
{
	return boost::apply_visitor( literal(), v );
}
 
template<class T>
void get( T &res, var_t v )
{
	static_assert( std::is_arithmetic<T>::value, "Shit type T" );
	res = boost::apply_visitor( numeric<T>(), v );
}
 
int main()
{
	var_t v1 = 100000;
	var_t v2 = 200000L;
	var_t v3 = "300000";
	var_t v4 = "test string";
 
	ushort		r1 = get<ushort>( v1 );
	long		r2 = get<long>( v2 );
	double		r3 = get<double>( v2 );
	long long	r4 = get<long long>( v1 );
	float		r5 = get<float>( v3 );
	short		r6 = get<short>( v3 );
	std::string	r7 = get<std::string>( v4 );
 
	cout << "r1 (short) = " << r1 << endl
		 << "r2 (long) = " << r2 << endl
		 << "r3 (double) = " << r3 << endl
		 << "r4 (long long) = " << r4 << endl
		 << "r5 (float) = " << r5 << endl
		 << "r6 (short) = " << r6 << endl
		 << "r7 (string) = " << r7 << endl;
 
	return 0;
}