Russian Qt Forum

C++ (Qt)
Variant v;
v = 10;
if (v.isType<int>())
    cout << v.value<int>() << endl;

• всё реализовано в одном заголовочном файле
• поддерживается сравнение по значению, если сравнение поддерживается хранимым типом
• зависит только от стандартной библиотеки C++ 11

• зависит от RTTI
• использует динамическую память под хранение значения
• C++03 не поддерживается

C++ (Qt)
Variant a, b, c;
..
Variant result = (a > 0) ? b : c;

C++ (Qt)
template <typename T>
    bool isType() const
    {
        return std::dynamic_pointer_cast<Holder<T>>(holder_) != 0;
    }
 

C++ (Qt)
template <typename T>
    const T& value() const throw (std::bad_cast)
    {
        if (!isType<T>())
            throw std::bad_cast();
        return std::static_pointer_cast<Holder<T>>(holder_)->value;
    }
 

• по просьбе Igors добавил возможность сравнивать Variant, теперь их можно размещать в std::map и прочие упорядоченные контейнеры
• также добавил возможность включения оптимизации кастования, которая сравнивает только указатели
• добавил тесты

C++ (Qt)
template <typename Type>
struct HasEqualOperator
{
typedef char yes[1];
typedef char no[2];
template <std::size_t N>
struct SFINAE {};
template <typename T>
static yes& isEqualComparable(SFINAE<sizeof(*static_cast<T*>(0) == *static_cast<T*>(0))>* = 0);
 

C++ (Qt)
variant<int, double, std::string> v = 10;
 
if (v.is_type<int>())
    std::cout << v.get<int>() << std::endl;
 
v = 0.5;
std::cout << v.get<double>() << std::endl;
 
v = std::string("hello-hello");
std::cout << v.get<std::string>() << std::endl;
 
 

C++ (Qt)
#include <iostream>
#include <list>
#include <variant.h>
 
 
typedef variant<int, double, std::string> my_variant;
 
void print_int(const my_variant & v)
{
    std::cout << " int " << v.get<int>() << std::endl;
}
 
void print_double(const my_variant & v)
{
    std::cout << " double " << v.get<double>() << std::endl;
}
 
void print_str(const my_variant & v)
{
    std::cout << " str " << v.get<std::string>() << std::endl;
}
 
int main()
{
    std::list<my_variant> list;
    list.push_back(10);
    list.push_back(0.5);
    list.push_back(std::string("hello-hello"));
 
 
    variant_visitor<int, double, std::string> my_visitor;
 
    my_visitor.reg<int>(&print_int);
    my_visitor.reg<double>(&print_double);
    my_visitor.reg<std::string>(&print_str);
 
    for (auto v : list)
        my_visitor(v);
 
    return 0;
}
 
 

Bash
int 10
double 0.5
str hello-hello
 

C++ (Qt)
#include <iostream>
#include <list>
#include <variant.h>
#include <string>
 
 
typedef variant<int, double, std::string> variant_t;
 
int main()
{
    std::list<variant_t> list;
    list.push_back(std::string("-42.45938"));  // string
    list.push_back(0.5);                                  // double
    list.push_back(std::string("2.34"));         // string 
    list.push_back(3.565);                            // double
    list.push_back(10);                                // int
 
 
    variant_visitor<double (variant_t)> my_visitor;
 
    my_visitor.reg<int>([](variant_t v) { return v.get<int>(); } );
    my_visitor.reg<double>([](variant_t v) { return v.get<double>(); } );
    my_visitor.reg<std::string>([](variant_t v) { return std::stod(v.get<std::string>()); } );
 
    for (auto v : list)
        std::cout << my_visitor(v) << std::endl;
 
    list.sort([&](variant_t v1, variant_t v2) { return my_visitor(v1) > my_visitor(v2); });
 
    std::cout << "--------------------------------" << std::endl;
 
    for (auto v : list)
        std::cout << my_visitor(v) << std::endl;
 
 
    return 0;
}
 

C++ (Qt)
bool IsLess( const Variant & v1, const Variant & v2 )
{
 double d1, d2;
 bool num1 = TryConvert2Double(v1, &d1);
 bool num2 = TryConvert2Double(v2, &d2);
 if (num1 && num2) 
  return d1 < d2;
 return num1 && !num2;
}

C++ (Qt)
bool TryConvert2Double( const Variant & v, double * result = 0 )
{
 if (v.is_type<int>()) {
  if (result) *result = v.get<int> ();
  return true;
 }
 
 if (v.is_type<double>()) {
  if (result) *result = v.get<double> ();
  return true;
 }
 
 if (v.is_type<std::string>()) 
  return TryStr2Double(v.get <std::string> (), &result);
 
 return false;
}

C++ (Qt)
list.sort([&](variant_t v1, variant_t v2)->bool
    {
        try {
            return my_visitor(v1) > my_visitor(v2);
        } catch (...) {
            return false;
        }
    });
 

C++ (Qt)
bool TryConvert2Double( const Variant & v, double * result = 0 )
{
 if (v.is_type<int>()) {
  if (result) *result = v.get<int> ();
  return true;
 }
 
 if (v.is_type<double>()) {
  if (result) *result = v.get<double> ();
  return true;
 }
 
 if (v.is_type<std::string>()) 
  return TryStr2Double(v.get <std::string> (), &result);
 
 return false;
}

C++ (Qt)
if (v.IsNumeric())   // реально ли это без перебора?
 double d = v.GetVal <double> ();

C++ (Qt)
#include <iostream>
#include <boost/variant.hpp>
 
 
template <class T>
struct numeric_visitor : public boost::static_visitor<T>
{
    T operator()(int val) const { return val; }
 
    T operator()(float val) const { return val; }
 
    T operator()(double val) const { return val; }
 
    template <class S>
    T operator()(S) const { return T(); } // или кидаем исключение..
};
 
template <class T>
struct string_visitor : public boost::static_visitor<T>
{
    T operator()(const std::string& val) const { return val; }
 
    template <class S>
    T operator()(S) const { return T(); } // или кидаем исключение
};
 
 
struct numeric_category : public boost::static_visitor<bool>
{
    bool operator()(double) const { return true; }
    bool operator()(float) const { return true; }
    bool operator()(int) const { return true; }
 
    template <class T>
    bool operator()(T) const { return false; }
 
};
 
struct string_category : public boost::static_visitor<bool>
{
    bool operator()(std::string) const { return true; }
 
    template <class T>
    bool operator()(T) const { return false; }
};
 
 
template <class V>
bool is_numeric(V v)
{
    return boost::apply_visitor(numeric_category(), v);
}
 
template <class V>
bool is_string(V v)
{
    return boost::apply_visitor(string_category(), v);
}
 
 
int main()
{
    typedef boost::variant<double, float, int, std::string> variant_t;
 
    variant_t v1 = 1.1234; // 10; 1.234f ...
    variant_t v2 = std::string("abc");
 
    if (is_numeric(v1))
        std::cout << "numeric: val = " << boost::apply_visitor(numeric_visitor<double>(), v1) << std::endl;
 
    if (is_string(v2))
        std::cout << "string: val = " << boost::apply_visitor(string_visitor<std::string>(), v2) << std::endl;
 
    return 0;
}
 

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)
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>(); });
 
    is_numeric.reg<std::string>([](variant_t v)->boost::optional<double>
    {
        try {
            return std::stod(v.get<std::string>());
        } catch (...) {
            return boost::optional<double>();
        }
    } );
 
 
    std::list<variant_t> list;
    list.push_back(1);
    list.push_back(123.456);
    list.push_back(std::string("abc"));
    list.push_back(std::string("6483.238578"));
 
    list.sort([&](variant_t v1, variant_t v2)->bool
    {
        auto x = is_numeric(v1);
        auto y = is_numeric(v2);
        return (x && y) ? (*x < *y) : (x && !y);
    });
 
 

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)
struct MyStruct {
	MyStruct( int val = 0 ) : mUseText(false), mVal(val) {}
	MyStruct( const char * str ) : mUseText(true), mStr(str) {}
 
	bool operator < ( const MyStruct & sec ) const
	{
		return toInt() < sec.toInt();
	}
 
	int		toInt() const
	{
		return  mUseText? std::numeric_limits<int>::max() : mVal;
	}
 
// data
	bool mUseText;
	union {
		int mVal;
		const char * mStr;
	};
};
 

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)
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();
    }
...
};
 

C++ (Qt)
QVariant v(5);
if (v.canConvert<double>())
	double d = v.toDouble();
 

C++ (Qt)
typedef MyClass<float, double, int, long, short, std::string> ClassNum;
 

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 = 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;
}
 

C++ (Qt)
    Variant v1 = 10;
    Variant v2 = v1;  // у v2 и v1 теперь общие  данные
 
    int *a;
 
    v1.tryGetValue(a); 
 
    std::cout << *a << std::endl;
 
    (*a) = 123;  
 
    std::cout << v2.value<int>() << std::endl; // v2 теперь тоже вернёт 123
 

C++ (Qt)
template <typename T>
    bool tryGetValue(T*& val)
    {
        if (!isType<T>())
            return false;
 
        if (!holder_.unique())
            holder_ = std::make_shared<Holder<T>>(typeid(T).name(), std::static_pointer_cast<Holder<T>>(holder_)->value);
 
        val = &(std::static_pointer_cast<Holder<T>>(holder_)->value);
        return true;
    }