我又来问问题啦，这回还是喜闻乐见的 C++问题，同样一份代码 MSCVC 19.24 ，clang 10 均可编译通过，g++-10 不可编译通过，这是什么原因呢，注意，须加入参数要求 compiler 支持 C++17 （-std=c++17), 可在线编译版本代码链接 https://godbolt.org/z/eWhsne ，源码如下， 其中开头部分的 type_traits 应该是没问题的，主要问题集中在 gcc 对 fold expression 的处理上,这份代码是对 std::variant 部分简单不完全实现 #include <type_traits> #include <utility> #include <new> #include <cassert> #include <exception> template <bool COND, typename TrueType, typename FalseType> class IfThenElseT { public: using Type = TrueType; }; template <typename TrueType, typename FalseType> class IfThenElseT<false, TrueType, FalseType> { public: using Type = FalseType; }; template <bool COND, typename TrueType, typename FalseType> using IfThenElse = typename IfThenElseT<COND, TrueType, FalseType>::Type; template <typename... Elements> class Typelist { }; template <typename List> class FrontT; template <typename Head, typename... Tail> class FrontT<Typelist<Head, Tail...>> { public: using Type = Head; }; template <typename List> using Front = typename FrontT<List>::Type; template <typename List> class PopFrontT; template <typename Head, typename... Tail> class PopFrontT<Typelist<Head, Tail...>> { public: using Type = Typelist<Tail...>; }; template <typename List> using PopFront = typename PopFrontT<List>::Type; template <typename List> class IsEmpty { public: static constexpr bool value = false; }; template <> class IsEmpty<Typelist<>> { public: static constexpr bool value = true; }; template <typename List, typename T, unsigned N = 0, bool Empty = IsEmpty<List>::value> struct FindIndexOf { }; template <typename List, typename T, unsigned N> struct FindIndexOf<List, T, N, false> : public IfThenElse<std::is_same_v<Front<List>, T>, std::integral_constant<unsigned, N>, FindIndexOf<PopFront<List>, T, N + 1>> { }; template <typename List, typename T, unsigned N> struct FindIndexOf<List, T, N, true> { }; template <typename List> class LargestTypeT; template <typename List> class LargestTypeT { private: using First = Front<List>; using Rest = typename LargestTypeT<PopFront<List>>::Type; public: using Type = IfThenElse<(sizeof(First) >= sizeof(Rest)), First, Rest>; }; template <> class LargestTypeT<Typelist<>> { public: using Type = char; }; template <typename List> using LargestType = typename LargestTypeT<List>::Type; template <typename... Types> class VariantStorage { private: using LargestT = LargestType<Typelist<Types...>>; alignas(Types...) unsigned char buffer[sizeof(LargestT)]; unsigned char discriminator = 0; public: unsigned char getDiscriminator() { return discriminator; } void setDiscriminator(unsigned char d) { discriminator = d; } void *getRawBuffer() { return buffer; } void const *getRawBuffer() const { return buffer; } template <typename T> T *getBufferAs() { return std::launder(reinterpret_cast<T *>(buffer)); } template <typename T> T const *getBufferAs() const { return std::launder(reinterpret_cast<T const *>(buffer)); } }; template <typename... Types> class Variant; template <typename T, typename... Types> class VariantChoice { private: using Derived = Variant<Types...>; Derived &getDerived() { return *static_cast<Derived *>(this); } Derived const &getDerived() const { return *static_cast<Derived const *>(this); } protected: constexpr static unsigned Discriminator = FindIndexOf<Typelist<Types...>, T>::value + 1; public: VariantChoice() = default; VariantChoice(T const &value); VariantChoice(T &&value); bool destroy(); Derived &operator=(T const &value); Derived &operator=(T &&value); }; template <typename T, typename... Types> VariantChoice<T, Types...>::VariantChoice(T const &value) { new (getDerived().getRawBuffer()) T(value); getDerived().setDiscriminator(Discriminator); } template <typename T, typename... Types> VariantChoice<T, Types...>::VariantChoice(T &&value) { new (getDerived().getRawBuffer()) T(std::move(value)); getDerived().setDiscriminator(Discriminator); } template <typename T, typename... Types> bool VariantChoice<T, Types...>::destroy() { if (getDerived().getDiscriminator() == Discriminator) { getDerived().template getBufferAs<T>()->~T(); return true; } return false; } template <typename T, typename... Types> auto VariantChoice<T, Types...>::operator=(T const &value) -> Derived & { if (getDerived().getDiscriminator() == Discriminator) { *getDerived().template getBufferAs<T>() = value; } else { getDerived().destroy(); new (getDerived().getRawBuffer()) T(value); getDerived().setDiscriminator(Discriminator); } return getDerived(); } template <typename T, typename... Types> auto VariantChoice<T, Types...>::operator=(T &&value) -> Derived & { if (getDerived().getDiscriminator() == Discriminator) { *getDerived().template getBufferAs<T>() = std::move(value); } else { getDerived().destroy(); new (getDerived().getRawBuffer()) T(std::move(value)); getDerived().setDiscriminator(Discriminator); } return getDerived(); } class ComputedResultType; class EmptyVariant : public std::exception { }; template <typename... Types> class Variant : private VariantStorage<Types...>, private VariantChoice<Types, Types...>... { template <typename T, typename... OtherTypes> friend class VariantChoice; public: using VariantChoice<Types, Types...>::VariantChoice...; //g++报错 using VariantChoice<Types, Types...>::operator=...; //g++报错 template <typename T> bool is() const; template <typename T> T &get() &; template <typename T> T &&get() &&; template <typename T> T const &get() const &; // template <typename R=ComputedResultType, typename Visitor> // VisitResult<R, Visitor bool empty() const; void destroy(); ~Variant() { destroy(); } private: }; template <typename... Types> template <typename T> bool Variant<Types...>::is() const { return this->getDiscriminator() == VariantChoice<T, Types...>::Discriminator; //g++报错 } template <typename... Types> template <typename T> T &Variant<Types...>::get() & { if (empty()) { throw EmptyVariant(); } assert(is<T>()); return *this->template getBufferAs<T>(); } template <typename... Types> template <typename T> T &&Variant<Types...>::get() && { if (empty()) { throw EmptyVariant(); } assert(is<T>()); return *this->template getBufferAs<T>(); } template <typename... Types> template <typename T> T const &Variant<Types...>::get() const & { if (empty()) { throw EmptyVariant(); } assert(is<T>()); return *this->template getBufferAs<T>(); } template <typename... Types> void Variant<Types...>::destroy() { // bool results[] = {VariantChoice<Types, Types...>::destroy()...}; (VariantChoice<Types, Types...>::destroy(), ...); //g++报错 this->setDiscriminator(0); } int main() { Variant<int> v{17}; return 0; }