Как boost::variant допускает строковые константы?
https://stackoverflow.com//questions/9609068
-
09-12-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Итак, я поиграл с наборщиками, и, боже, какие они интересные.Одна из вещей, которые я хотел сделать, это попытаться реализовать свой собственный variant занятие просто как образовательный эксперимент по изучению того, как работают наборщики и чем они могут быть полезны.Вот как на данный момент выглядит мой код:
#include <cstddef>
#include <typeinfo>
#ifndef VARIANT_H_
#define VARIANT_H_
struct NullType {};
template <class T, class U>
struct TypeList {
typedef T Head;
typedef U Tail;
};
#define TYPELIST_1(T1) TypeList<T1, NullType>
#define TYPELIST_2(T1, T2) TypeList<T1, TYPELIST_1(T2) >
#define TYPELIST_3(T1, T2, T3) TypeList<T1, TYPELIST_2(T2, T3) >
#define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TYPELIST_3(T2, T3, T4) >
#define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TYPELIST_4(T2, T3, T4, T5) >
#define TYPELIST_6(T1, T2, T3, T4, T5, T6) TypeList<T1, TYPELIST_5(T2, T3, T4, T5, T6) >
#define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) TypeList<T1, TYPELIST_6(T2, T3, T4, T5, T6, T7) >
#define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) TypeList<T1, TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
#define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) TypeList<T1, TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
namespace util {
namespace {
template <class TL> struct MaxSize;
template <class TL> struct Length;
template <class TL, class T> struct IndexOf;
template <class TL, unsigned int i> struct TypeAt;
template <>
struct MaxSize<NullType> {
static const size_t value = 0;
};
template <class Head, class Tail>
struct MaxSize<TypeList<Head, Tail> > {
static const size_t value = (sizeof(Head) > MaxSize<Tail>::value) ? sizeof(Head) : MaxSize<Tail>::value;
};
template <>
struct Length<NullType> {
enum { value = 0 };
};
template <class Head, class Tail>
struct Length<TypeList<Head, Tail> > {
enum { value = 1 + Length<Tail>::value };
};
template <class T>
struct IndexOf<NullType, T> {
enum { value = -1 };
};
template <class Tail, class T>
struct IndexOf<TypeList<T, Tail>, T> {
enum { value = 0 };
};
template <class Head, class Tail, class T>
struct IndexOf<TypeList<Head, Tail>, T> {
enum { value = (IndexOf<Tail, T>::value == -1) ? -1 : 1 + IndexOf<Tail, T>::value };
};
template <class Head, class Tail>
struct TypeAt<TypeList<Head, Tail>, 0> {
typedef Head type;
};
template <class Head, class Tail, unsigned int i>
struct TypeAt<TypeList<Head, Tail>, i> {
typedef typename TypeAt<Tail, i - 1>::type type;
};
}
template <class TL>
class variant;
template<class U, class TL>
U *get(variant<TL> *v);
template<class U, class TL>
const U *get(const variant<TL> *v);
template<class U, class TL>
U &get(variant<TL> &v);
template<class U, class TL>
const U &get(const variant<TL> &v);
// this stuff is a visitation pattern used to make sure
// that contained objects get properly destroyed
namespace {
template <class TL>
struct apply_visitor;
struct destroy_visitor {
template <class T>
void operator()(T *p) {
p->~T();
}
};
template <class H, class T>
struct visitor_impl {
template <class U, class Pred>
static void visit(U *p, Pred pred) {
if(H *x = get<H>(p)) {
pred(x);
} else {
apply_visitor<T>::visit(p, pred);
}
}
};
template <class H>
struct visitor_impl<H, NullType> {
template <class U, class Pred>
static void visit(U *p, Pred pred) {
if(H *x = get<H>(p)) {
pred(x);
} else {
throw std::bad_cast();
}
}
};
template <class TL>
struct apply_visitor {
typedef typename TL::Head H;
typedef typename TL::Tail T;
template <class U, class Pred>
static void visit(U *p, Pred pred) {
visitor_impl<H, T>::visit(p, pred);
}
};
}
template <class TL>
class variant {
template<class U, class X> friend U *get(variant<X> *v);
template<class U, class X> friend const U *get(const variant<X> *v);
template<class U, class X> friend U &get(variant<X> &v);
template<class U, class X> friend const U &get(const variant<X> &v);
public :
variant() : type_index_(0){
new (&storage_) typename TypeAt<TL, 0>::type();
}
~variant() {
apply_visitor<TL>::visit(this, destroy_visitor());
}
template <class T>
variant(const T &x) : type_index_(IndexOf<TL, T>::value) {
typedef typename TypeAt<TL, IndexOf<TL, T>::value>::type value_type;
new (&storage_) value_type(x);
}
template <class T>
variant(T &x) : type_index_(IndexOf<TL, T>::value) {
typedef typename TypeAt<TL, IndexOf<TL, T>::value>::type value_type;
new (&storage_) value_type(x);
}
template <class T>
variant &operator=(const T &rhs) {
variant(rhs).swap(*this);
return *this;
}
variant &operator=(const variant &rhs) {
variant(rhs).swap(*this);
return *this;
}
public:
void swap(variant &other) {
using std::swap;
swap(storage_, other.storage_);
swap(type_index_, other.type_index_);
}
private:
template <class T>
const T &get_ref() const {
typedef typename TypeAt<TL, IndexOf<TL, T>::value>::type value_type;
if(IndexOf<TL, T>::value != type_index_) {
throw std::bad_cast();
}
return *reinterpret_cast<const value_type *>(&storage_);
}
template <class T>
T &get_ref() {
typedef typename TypeAt<TL, IndexOf<TL, T>::value>::type value_type;
if(IndexOf<TL, T>::value != type_index_) {
throw std::bad_cast();
}
return *reinterpret_cast<value_type *>(&storage_);
}
template <class T>
const T *get_ptr() const {
typedef typename TypeAt<TL, IndexOf<TL, T>::value>::type value_type;
if(IndexOf<TL, T>::value != type_index_) {
return 0;
}
return reinterpret_cast<const value_type *>(&storage_);
}
template <class T>
T *get_ptr() {
typedef typename TypeAt<TL, IndexOf<TL, T>::value>::type value_type;
if(IndexOf<TL, T>::value != type_index_) {
return 0;
}
return reinterpret_cast<value_type *>(&storage_);
}
public:
int which() const {
return type_index_;
}
bool empty() const {
return false;
}
const std::type_info &type() const;
private:
struct { unsigned char buffer_[MaxSize<TL>::value]; } storage_;
int type_index_;
};
// accessors
template<class U, class TL>
U *get(variant<TL> *v) {
return v->template get_ptr<U>();
}
template<class U, class TL>
const U *get(const variant<TL> *v) {
return v->template get_ptr<U>();
}
template<class U, class TL>
U &get(variant<TL> &v) {
return v.template get_ref<U>();
}
template<class U, class TL>
const U &get(const variant<TL> &v) {
return v.template get_ref<U>();
}
}
#endif
И это работает очень хорошо!Я могу написать что-то вроде следующего, и это отлично работает:
typedef util::variant<TYPELIST_3(std::string, int, double)> variant;
variant x = std::string("hello world");
variant y = 10;
variant z = 123.45;
std::cout << util::get<std::string>(x) << std::endl;
std::cout << util::get<int>(y) << std::endl;
std::cout << util::get<double>(z) << std::endl;
И все работает как положено :-).Вот мой вопрос.С boost::variant Я могу написать следующее без каких-либо проблем:
boost::variant<int, std::string> v = "hello world";
С моей версией, если я напишу аналогично:
util::variant<TYPELIST_2(int, std::string)> v = "hello world";
Я получаю сообщение об ошибке, подобное этому:
variant.hpp: In instantiation of 'util::<unnamed>::TypeAt<TypeList<std::basic_string<char>, NullType>, 4294967294u>':
variant.hpp:76:47: instantiated from 'util::<unnamed>::TypeAt<TypeList<int, TypeList<std::basic_string<char>, NullType> >, 4294967295u>'
variant.hpp:161:61: instantiated from 'util::variant<TL>::variant(const T&) [with T = char [12], TL = TypeList<int, TypeList<std::basic_string<char>, NullType> >]'
test.cc:27:50: instantiated from here
variant.hpp:76:47: error: invalid use of incomplete type 'struct util::<unnamed>::TypeAt<NullType, 4294967293u>'
variant.hpp:32:46: error: declaration of 'struct util::<unnamed>::TypeAt<NullType, 4294967293u>'
По сути, он не может найти char[12] в списке типов в варианте.Что имеет смысл, поскольку char[12] на самом деле явно не указан как один из типов...
Как это происходит boost::variant сделать так, чтобы это работало так гладко? Я чувствую, что это единственная реальная недостающая деталь в моем понимании того, как boost::variant работает.Мысли?
Решение
Вы не хотите делать is_convertible, как было предложено в другом ответе.По сути, вы бы переопределили механизм преобразования C ++, используя признаки типа C ++.Вместо этого вы можете использовать инфраструктуру C ++, которая у вас уже есть.
Способ, которым boost делает это, заключается в наличии класса с функцией, которая принимает все типы, которые может принять данный вариант.Я не уверен, как boost делает это именно с C ++ 03, но в синтаксисе C ++ 11:
template <typename First, typename... Rest>
class constructor : public constructor<Rest...>
{
using constructor<Rest...>::construct;
static void
construct(variant& v, First&& value);
};
Затем ваш operator= и другие функции вызывают constructor<Types...>::construct(*this, value) и если есть однозначное преобразование, то C ++ найдет его для вас.
Я написал довольно подробный пост в блоге, в котором описал, как все это работает: http://thenewcpp.wordpress.com/2012/02/15/variadic-templates-part-3-or-how-i-wrote-a-variant-class/
Другие советы
Вы можете использовать такие признаки типа, как is_convertible (или версия C ++ 11 stdlib).
Как говорится в комментарии @Andreas, вам нужно немного изменить свой шаблонный конструктор / оператор присваивания, например, искать не определенный тип, а первое совпадение.
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_convertible.hpp>
template<class T, class TList>
struct FirstMatch;
template<class T, class Head, class Tail>
struct FirstMatch<T, TypeList<Head, Tail>>{
static bool const is_conv = boost::is_convertible<T, Head>::value;
typedef typename boost::mpl::if_c<is_conv, Head,
typename FirstMatch<T, Tail>::type>::type type;
};
template<class T>
struct FirstMatch<T, NullType>{
typedef struct ERROR_no_convertible_type_found type;
};
template<class T, class TList>
struct FirstOrExactMatch{
static int const idx = IndexOf<TList, T>::value;
typedef typename boost::mpl::if_c<idx != -1,
TypeAt<TList, idx>,
FirstMatch<T, TList>
>::type::type type;
};
Код непроверен, но должен работать (за вычетом опечаток).
