Clone of Boost Variant

Als onderdeel van het leren van C ++, met speciale nadruk op C ++ 11, wilde ik het equivalent van Boosts Variant (gelokaliseerd hier ). Mijn code is beschikbaar op variant.hpp , met de huidige versie hieronder .

Hoe kan std::aligned_storage draagbaar worden gebruikt? Mijn huidige oplossing maakt waarschijnlijk niet-draagbaar gebruik van static_cast als het draagbaar is, zou die informatie erg waardevol zijn. De specifieke code is vergelijkbaar met *static_cast<T*>(static_cast<void*>(&value)), voor value van het type typename std::aligned_storage<...>::type (waarbij ... niet bedoeld is om variadische sjablonen aan te duiden).

Ik maak enig gebruik van static_assert. Zou SFINAE bij dit specifieke gebruik beter zijn? Ik begrijp dat SFINAE kan worden gebruikt om overbelastingen uit de set van levensvatbare functies te verwijderen, maar waar ik static_assert gebruik, neem daar aan zou slechts één levensvatbare functie zijn, hoewel ik waardevolle voorbeelden zou vinden van gevallen waarin er meer dan één levensvatbare functie is.

Ik heb veel gebruik gemaakt van std::forward. Is het mogelijk om rond te komen met minder gebruik?

Ik heb std::enable_if gebruikt bij een van de constructor-overloads om ervoor te zorgen dat het alleen zou worden gebruikt bij een verplaatsing is bedoeld (zie variant(U&& value, typename detail::variant::enable_if_elem<U, T...>::type* = nullptr, typename detail::variant::enable_if_movable<U>::type* = nullptr)). Zonder beide enable_if s, zou deze constructor worden gebruikt wanneer de kopieerconstructor variant(variant const&) in plaats daarvan bedoeld is, ook al resulteert de eerste in een eventuele compileerfout. Is er een betere manier om dit gedrag af te dwingen? Een oplossing die ik heb geprobeerd, was variant(variant&) opnemen als een overbelasting die zich gewoon verplaatst naar variant(variant const& rhs) – het zou worden geselecteerd via variant(U&&), terwijl variant(U&&) de voorkeur heeft boven variant(variant const&) door de overbelastingsregels. Wat is de algemene beste praktijk bij het gebruik van T&& voor sommige nieuw geïntroduceerde T wanneer verplaatsingssemantiek bedoeld is in plaats van een universele referentie?

Ik moet nog steeds multivisitors toevoegen, hoewel ik hier in het algemeen wat problemen mee heb (met behulp van variadische sjablonen). Iets interessants dat naar voren kwam bij het implementeren van de variant -klasse waren impliciete conversies tussen variant s waarbij alleen de sjabloonargumenten moesten worden herschikt of waarbij de lvalue-sjabloon argumenten zijn een superset van de rvalue-sjabloonargumenten.

Alle opmerkingen, vragen of advies worden zeer op prijs gesteld.

#ifndef WART_VARIANT_HPP #define WART_VARIANT_HPP #include <type_traits> #include <utility> #include "math.hpp" namespace wart { template <typename... T> class variant; namespace detail { namespace variant { template <typename... T> using variant = wart::variant<T...>; template <typename T> using is_movable = typename std::integral_constant <bool, std::is_rvalue_reference<T&&>::value && !std::is_const<T>::value>; template <typename T, typename U = void> using enable_if_movable = std::enable_if<is_movable<T>::value, U>; template <typename... Types> using union_storage = typename std::aligned_storage <math::max_constant<std::size_t, sizeof(Types)...>::value, math::lcm_constant<std::size_t, std::alignment_of<Types>::value...>::value>::type; template <typename... Types> using union_storage_t = typename union_storage<Types...>::type; template <typename Elem, typename... List> struct elem; template <typename Head, typename... Tail> struct elem<Head, Head, Tail...>: std::true_type {}; template <typename Elem, typename Head, typename... Tail> struct elem<Elem, Head, Tail...>: elem<Elem, Tail...>::type {}; template <typename Elem> struct elem<Elem>: std::false_type {}; template <typename Elem, typename... List> struct elem_index; template <typename Head, typename... Tail> struct elem_index<Head, Head, Tail...>: std::integral_constant<int, 0> {}; template <typename Elem, typename Head, typename... Tail> struct elem_index<Elem, Head, Tail...>: std::integral_constant<int, elem_index<Elem, Tail...>::value + 1> {}; template <bool... List> struct all; template <> struct all<>: std::true_type {}; template <bool... Tail> struct all<true, Tail...>: all<Tail...>::type {}; template <bool... Tail> struct all<false, Tail...>: std::false_type {}; template <typename Elem, typename... List> using enable_if_elem = std::enable_if<elem<Elem, List...>::value>; template <typename F, typename... ArgTypes> using common_result_of = std::common_type<typename std::result_of<F(ArgTypes)>::type...>; struct destroy { template <typename T> void operator()(T&& value) { using type = typename std::remove_reference<T>::type; std::forward<T>(value).~type(); } }; struct copy_construct { void* storage; template <typename T> void operator()(T const& value) { new (storage) T(value); } }; template <typename... T> struct copy_construct_index { void* storage; template <typename U> int operator()(U const& value) { new (storage) U(value); return elem_index<U, T...>::value; } }; struct move_construct { void* storage; template <typename T> typename enable_if_movable<T>::type operator()(T&& value) { new (storage) T(std::move(value)); } }; template <typename... T> struct move_construct_index { void* storage; template <typename U> typename enable_if_movable<U, int>::type operator()(U&& value) { new (storage) U(std::move(value)); return elem_index<U, T...>::value; } }; struct copy_assign { void* storage; template <typename T> void operator()(T const& value) { *static_cast<T*>(storage) = value; } }; template <typename... T> struct copy_assign_reindex { variant<T...>& variant; template <typename U> void operator()(U const& value) { if (variant.which_ == elem_index<U, T...>::value) { *static_cast<U*>(static_cast<void*>(&variant.storage_)) = value; } else { variant.accept(destroy{}); new (&variant.storage_) U(value); variant.which_ = elem_index<U, T...>::value; } } }; struct move_assign { void* storage; template <typename T> typename enable_if_movable<T>::type operator()(T&& value) { *static_cast<T*>(storage) = std::move(value); } }; template <typename... T> struct move_assign_reindex { variant<T...>& variant; template <typename U> typename enable_if_movable<U>::type operator()(U&& value) { if (variant.which_ == elem_index<U, T...>::value) { *static_cast<U*>(static_cast<void*>(&variant.storage_)) = std::move(value); } else { variant.accept(destroy{}); new (&variant.storage_) U(std::move(value)); variant.which_ = elem_index<U, T...>::value; } } }; } } template <typename... T> class variant { int which_; detail::variant::union_storage_t<T...> storage_; public: template <typename F> using result_of = detail::variant::common_result_of<F, T...>; template <typename F> using result_of_t = typename result_of<F>::type; template <typename U> variant(U const& value, typename detail::variant::enable_if_elem<U, T...>::type* = nullptr): which_{detail::variant::elem_index<U, T...>::value} { new (&storage_) U(value); } template <typename U> variant(U&& value, typename detail::variant::enable_if_elem<U, T...>::type* = nullptr, typename detail::variant::enable_if_movable<U>::type* = nullptr): which_{detail::variant::elem_index<U, T...>::value} { new (&storage_) U(std::move(value)); } variant(variant const& rhs): which_{rhs.which_} { rhs.accept(detail::variant::copy_construct{&storage_}); } template <typename... U> variant(variant<U...> const& rhs, typename std::enable_if< detail::variant::all<detail::variant::elem<U, T...>::value...>::value >::type* = nullptr): which_{rhs.accept(detail::variant::copy_construct_index<T...>{&storage_})} {} variant(variant&& rhs): which_{rhs.which_} { std::move(rhs).accept(detail::variant::move_construct{&storage_}); } template <typename... U> variant(variant<U...>&& rhs, typename std::enable_if< detail::variant::all<detail::variant::elem<U, T...>::value...>::value >::type* = nullptr): which_{std::move(rhs).accept(detail::variant::move_construct_index<T...>{&storage_})} {} ~variant() { accept(detail::variant::destroy{}); } variant& operator=(variant const& rhs) & { using namespace detail::variant; static_assert(all<std::is_nothrow_copy_constructible<T>::value...>::value, "all template arguments T must be nothrow copy constructible in class template variant"); if (this == &rhs) { return *this; } if (which_ == rhs.which_) { rhs.accept(copy_assign{&storage_}); } else { accept(destroy{}); rhs.accept(copy_construct{&storage_}); which_ = rhs.which_; } return *this; } template <typename... U> variant& operator=(variant<U...> const& rhs) & { using namespace detail::variant; static_assert(all<std::is_nothrow_copy_constructible<T>::value...>::value, "all template arguments T must be nothrow copy constructible in class template variant"); rhs.accept(copy_assign_reindex<T...>{*this}); return *this; } variant& operator=(variant&& rhs) & { using namespace detail::variant; static_assert(all<std::is_nothrow_move_constructible<T>::value...>::value, "all template arguments T must be nothrow move constructible in class template variant"); if (this == &rhs) { return *this; } if (which_ == rhs.which_) { std::move(rhs).accept(move_assign{&storage_}); } else { accept(detail::variant::destroy{}); std::move(rhs).accept(move_construct{&storage_}); which_ = rhs.which_; } return *this; } template <typename... U> variant& operator=(variant<U...>&& rhs) & { using namespace detail::variant; static_assert(all<std::is_nothrow_copy_constructible<T>::value...>::value, "all template arguments T must be nothrow copy constructible in class template variant"); std::move(rhs).accept(move_assign_reindex<T...>{*this}); return *this; } template <typename F> result_of_t<F> accept(F&& f) const& { using namespace detail::variant; using call = result_of_t<F&&> (*)(F&& f, union_storage_t<T...> const&); static call calls[] { [](F&& f, union_storage_t<T...> const& value) { return std::forward<F>(f)(*static_cast<T const*>(static_cast<void const*>(&value))); }... }; return calls[which_](std::forward<F>(f), storage_); } template <typename F> result_of_t<F> accept(F&& f) & { using namespace detail::variant; using call = result_of_t<F&&> (*)(F&& f, union_storage_t<T...>&); static call calls[] { [](F&& f, union_storage_t<T...>& value) { return std::forward<F>(f)(*static_cast<T*>(static_cast<void*>(&value))); }... }; return calls[which_](std::forward<F>(f), storage_); } template <typename F> result_of_t<F> accept(F&& f) && { using namespace detail::variant; using call = result_of_t<F> (*)(F&& f, union_storage_t<T...>&&); static call calls[] { [](F&& f, union_storage_t<T...>&& value) { return std::forward<F>(f)(std::move(*static_cast<T*>(static_cast<void*>(&value)))); }... }; return calls[which_](std::forward<F>(f), std::move(storage_)); } friend struct detail::variant::copy_assign_reindex<T...>; friend struct detail::variant::move_assign_reindex<T...>; }; } #endif 

Reacties

• Ook volgens ons helpcentrum is dit niet de site voor code die niet ‘ doet wat hij moet doen Doen. Werkt uw code werkt ?
• Als door ” werkt “, bedoel je, ” compileert het? “, het compileert met clang ++ versie 3.3, maar compileert niet met g ++ versie 4.8.2 vanwege een interactie tussen parameterpakketten en lambdas. Het CMakeLists.txt-bestand selecteert clang ++ onvoorwaardelijk. Als ” werk “, bedoel je ” is het draagbaar? “, nee, het is misschien niet draagbaar. Dit komt door de manier waarop ik std::aligned_storage gebruik. Advies over het draagbare gebruik van de bijbehorende type zou zeer nuttig zijn. Als door ” werk “, bedoel je ” voldoet het aan de oorspronkelijke bedoeling? “, het antwoord is ja, hoewel ik heel graag stilistisch advies en best practices zou willen.
• Het gebruik van std::forward ziet er goed uit, ik kan ‘ nergens zien waar je het niet kon gebruiken. Ik geef de voorkeur aan static_assert omdat je hierdoor betere foutmeldingen kunt geven. Draagbaarheid is mogelijk een probleem, aangezien er geen garantie is dat alle verwijzingen op dezelfde grens zijn uitgelijnd (dus void * en T* kunnen verschillende vereisten hebben ), maar dit zou tegenwoordig zeer ongebruikelijk zijn. Ik ‘ weet niet hoe boost hier omheen komt, of dat ze het gewoon negeren.
• @Yuushi, allereerst bedankt dat je de tijd hebt genomen om dit te beoordelen . Ik denk dat ze alle niet-draagbare dingen gewoon negeren ( boost.org/doc/libs/1_55_0/boost/variant/detail/cast_storage.hpp ). Ik heb een draagbare oplossing gevonden ( github.com/sonyandy/cpp-experiments/blob/master/include/wart/… ) die een techniek gebruikt die vergelijkbaar is met wat std::tuple gebruikt, maar met union.
• Geen probleem.Het enige andere dat ik ‘ toevoeg, is dat het bestand een beetje ” bezig lijkt ” en er staan dingen in die op zichzelf mogelijk nuttig zijn (eigenschappen die u ‘ hebt gedefinieerd zoals is_movable en enable_if_movable, bijvoorbeeld) die mogelijk ergens anders zou kunnen wonen. Helaas bestaat het aantal C ++ – recensenten hier met de kennis die nodig is om u hierover goede feedback te geven waarschijnlijk in de enkele cijfers, aangezien de code vrij complex is.