كيف يسمح Boost::variant بثوابت السلسلة؟

StackOverflow https://stackoverflow.com//questions/9609068

  •  09-12-2019
  •  | 
  •  

سؤال

لقد كنت أتلاعب بالقوائم الكاتبة وتساءلت هل هي مثيرة للاهتمام.أحد الأشياء التي أردت القيام بها هو محاولة تنفيذ ما أقوم به 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++ المتوفرة لديك بالفعل.

الطريقة التي يتم بها التعزيز هي من خلال وجود فئة ذات وظيفة تأخذ كل نوع يمكن أن يقبله المتغير.لست متأكدًا من كيفية عمل التعزيز بالضبط مع 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);
};

ثم يتم استدعاء المشغل = والوظائف الأخرى 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;
};

لم يتم اختبار الكود، ولكن يجب أن يعمل (باستثناء الأخطاء المطبعية).

مرخصة بموجب: CC-BY-SA مع الإسناد
لا تنتمي إلى StackOverflow
scroll top