दिलचस्प पोस्ट
छवि को पुनः लोड किए बिना जावास्क्रिप्ट से एनिमेटेड जीआईआई को पुनरारंभ करें स्ट्रिंग को पायथन में यूटीएफ -8 में कनवर्ट कैसे करें आईफ़ोन: वर्तमान मिलीसेकंड कैसे प्राप्त करें? UITextField पाठ पर ड्रॉप शेड मैं एक रेल संपादन फ़ील्ड में दिखाए गए मूल्य को कैसे प्रारूपित कर सकता हूं? '' इस '' के साथ कोई प्रकार / अंतर के साथ स्पष्ट स्वयं-संदर्भ जावास्क्रिप्ट सरणियों विरल हैं? जावास्क्रिप्ट में गतिशील चर नाम का उपयोग करें PHP के माध्यम से MySQL डाटाबेस आउटपुट प्राप्त करें मैं कैसे कर सकता हूँ एक WPF कॉम्बो बॉक्स XAML में इसके व्यापक तत्व की चौड़ाई है? धारा बनाम दृश्य बनाम Iterators सीएसवी पाठक (पायथन) में "पंक्ति में शून्य बाइट शामिल है" मेटप्ललिब में सबप्लेट के अंदर छोटे भूखंडों को एम्बेड करना एंड्रॉइड पर OAuth 2.0 के लिए साइनिंग सर्टिफ़िकेट फ़िंगरप्रिंट (एसएचए 1) कैसे प्राप्त करें? स्लैला लैम्ब्डा फ़ंक्शन में _ का उपयोग

अद्वितीयता के लिए वैराडीक टेम्प्लेट पैरामीटर की जांच करें

मैं चाहता हूँ कि variadic टेम्पलेट पैरामीटर अद्वितीय होना चाहिए। मुझे पता है जब बहु विरासत, समान कक्षाएं विरासत की अनुमति नहीं है

struct A{}; struct B: A, A{}; // error 

इस नियम का उपयोग करते हुए, मैंने एक छोटा कोड बनाया।

 #include <type_traits> template< class T> struct id{}; template< class ...T> struct base_all : id<T> ... {}; template< class ... T> struct is_unique { template< class ... U> static constexpr bool test( base_all<U...> * ) noexcept { return true; } template< class ... U> static constexpr bool test( ... ) noexcept { return false;} static constexpr bool value = test<T...>(0); }; int main() { constexpr bool b = is_unique<int, float, double>::value; // false -- Why? constexpr bool c = is_unique< int, char, int>::value; // false static_assert( b == true && c == false , "!");// failed. } 

लेकिन मेरे कार्यक्रम के रूप में मुझे उम्मीद है काम नहीं किया है क्या गलत है?

// अद्यतन: // धन्यवाद, मैं अपनी त्रुटि ठीक करता हूं: //

 // #include <type_traits> // #include <cstddef> // // template< class ... U> struct pack{}; // // template< class T> struct id{}; // template< class T> struct base_all; // template< class ... T> struct base_all< pack<T...> > : id<T> ... {}; // // // // template< class ... T> // struct is_unique // { // template< class P, std::size_t = sizeof(base_all<P>) > // struct check; // // template< class ...U> // static constexpr bool test(check< pack<U...> > * ) noexcept { return true;} // // template< class ... U> // static constexpr bool test(...)noexcept { return false;} // // static constexpr bool value = test<T...>(0); // }; // // int main() // { // constexpr bool b = is_unique<int, float, double>::value; // true // constexpr bool c = is_unique< int, char, int>::value; // false // // static_assert( b == true && c == false , "!");// success. // } // 

प्रश्न: कोई यह समझा सकता है, यह क्यों असफल है?

UPDATE2: मेरा पिछला अपडेट अवैध था :)) कानूनी रूप, लेकिन यह हे (एन) समय संकलित

 #include <cstddef> #include <iostream> #include <type_traits> namespace mpl { template< class T > using invoke = typename T :: type ; template< class C, class I, class E > using if_t = invoke< std::conditional< C{}, I, E> >; template< class T > struct id{}; struct empty{}; template< class A, class B > struct base : A, B {}; template< class B , class ... > struct is_unique_impl; template< class B > struct is_unique_impl<B>: std::true_type{}; template< class B, class T, class ... U> struct is_unique_impl<B, T, U...> : if_t< std::is_base_of< id<T>, B>, std::false_type, is_unique_impl< base<B,id<T>>, U...> >{}; template< class ...T >struct is_unique : is_unique_impl< empty, T ... > {}; } // mpl int main() { constexpr bool b = mpl::is_unique<int, float, double>::value; constexpr bool c = mpl::is_unique< int, char, int > :: value; static_assert( b == true , "!"); static_assert( c == false, "!"); return 0; } 

Solutions Collecting From Web of "अद्वितीयता के लिए वैराडीक टेम्प्लेट पैरामीटर की जांच करें"

base_all<U...> लिए एक संकेतक पास करना केवल base_all<U...> की घोषणा के अस्तित्व की आवश्यकता है। परिभाषा तक पहुंचने का प्रयास किए बिना, संकलक यह नहीं पता लगाएगा कि प्रकार वास्तव में बीमार-परिभाषित है। उस समस्या को कम करने के लिए एक दृष्टिकोण एक तर्क का उपयोग करना होगा जिसमें base_all<U...> की परिभाषा की आवश्यकता है, जैसे:

 template< class ...T> struct base_all : id<T> ... { typedef int type; }; // ... template< class ... U> static constexpr bool test(typename base_all<U...>::type) noexcept { return true; } 

हालांकि, ऊपर दिए गए प्रश्नों के उत्तर में, यह संकलित करने में विफल रहता है: एसपीआईएनईई के लिए माना जाने वाला बहुमूल्य विरासत एक उपयुक्त संदर्भ में नहीं है। मुझे नहीं लगता कि आप एक ही आधार को दो बार से विरासत में लाने की इजाजत नहीं दे सकते हैं। प्रासंगिक परीक्षण अलग तरीके से लागू किया जा सकता है, यद्यपि:

 #include <type_traits> template <typename...> struct is_one_of; template <typename F> struct is_one_of<F> { static constexpr bool value = false; }; template <typename F, typename S, typename... T> struct is_one_of<F, S, T...> { static constexpr bool value = std::is_same<F, S>::value || is_one_of<F, T...>::value; }; template <typename...> struct is_unique; template <> struct is_unique<> { static constexpr bool value = true; }; template<typename F, typename... T> struct is_unique<F, T...> { static constexpr bool value = is_unique<T...>::value && !is_one_of<F, T...>::value; }; int main() { constexpr bool b = is_unique<int, float, double>::value; constexpr bool c = is_unique< int, char, int>::value; static_assert( b == true && c == false , "!"); } 

एक अन्य ओ (लॉगएन) तत्काल गहराई समाधान इसके लिए अभी भी एक बड़ी सफाई, टिप्पणियां, नाम स्थान, नाम बदलने और कम कोड दोहराव की आवश्यकता है।

यश फिर से क्सीओ के लिए , जिनके हे (लॉगएन) जीएन_सेक का तत्काल गहराई संस्करण यह (पुनः) निर्भर करता है।

 #include <cstddef> // using aliases for cleaner syntax template<class T> using Invoke = typename T::type; template<std::size_t...> struct seq{ using type = seq; }; template<class S1, class S2> struct concat; template<std::size_t... I1, std::size_t... I2> struct concat<seq<I1...>, seq<I2...>> : seq<I1..., (sizeof...(I1)+I2)...>{}; template<class S1, class S2> using Concat = Invoke<concat<S1, S2>>; template<std::size_t N> struct gen_seq; template<std::size_t N> using GenSeq = Invoke<gen_seq<N>>; template<std::size_t N> struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{}; template<> struct gen_seq<0> : seq<>{}; template<> struct gen_seq<1> : seq<0>{}; 

इंडेक्स क्रम पीढ़ी के अलावा, इस समाधान में ओ (1) तत्काल गहराई भी होनी चाहिए। बहु भाग के बजाय, यह एक std::array<std::false_type, size> का उपयोग ओ (1) -विस्तार-गहराई या एसएफआईएनएई के माध्यम से करता है।

is_one_of कार्यान्वयन ध्यान दें कि "इनमें से एक है" की विपरीत अवधारणा "अद्वितीय है"

 #include <array> // check if `T` is in `Us...` template<class T, class... Us> struct is_one_of { template<class T1> static constexpr auto SFINAE(int) -> decltype( std::array<std::false_type, sizeof...(Us)> {{std::is_same<T1, Us>{}...}} ) { return {}; /* only to suppress warning */ } template<class...> static constexpr int SFINAE(...) { return 42; } template<class T1> static constexpr bool test() { return std::is_same<decltype(SFINAE<T1>(0)), int>{}; } static constexpr bool value = test<T>(); constexpr operator bool() const { return value; } }; 

are_unique कार्यान्वयन:

 namespace detail { // `Any` type with a generic no-constraint ctor // to discard a number of arguments for a function template template<std::size_t> struct Any { template<class T> constexpr Any(T&&) {} }; // `wrapper` is used as a substitute for `declval`, // and can keep track if `T` is a reference template<class T> struct wrapper { using type = T; }; template<std::size_t I, class T, class... Us> struct is_one_of_pack { template<std::size_t... I1s> struct helper { template<class... Remaining> static constexpr bool deduce_remaining(Any<I1s>..., Remaining...) { // unique <-> is one of return not is_one_of<T, typename Remaining::type...>{}; } }; template<std::size_t... I1s> static constexpr bool deduce_seq(seq<I1s...>) { return helper<I1s...>::template deduce_remaining(wrapper<Us>()...); } static constexpr bool create_seq() { return deduce_seq(gen_seq<I+1>{}); } using type = std::integral_constant<bool, create_seq()>; }; template<class... Packs> constexpr auto SFINAE(int) -> decltype( std::array<std::true_type, sizeof...(Packs)> {{typename Packs::type{}...}} ) { return {}; /* only to suppress warning */ } template<class...> static constexpr int SFINAE(...) { return 42; } template<class... Packs> constexpr bool test() { return std::is_same<decltype(SFINAE<Packs...>(0)), int>{}; } template<class... Ts, std::size_t... Is> constexpr bool deduce_seq(seq<Is...>) { return test< is_one_of_pack<Is, Ts, Ts...>... >(); } } template<class... Ts> struct are_unique : std::integral_constant<bool, detail::deduce_seq<Ts...>(gen_seq<sizeof...(Ts)>{})> {}; 

उपयोग का उदाहरण:

 #include <iostream> #include <iomanip> int main() { bool a = are_unique<bool, char, int>(); bool b = are_unique<bool, char, int, bool>(); bool c = are_unique<bool, char, bool, int>(); std::cout << std::boolalpha; std::cout << a << std::endl; std::cout << b << std::endl; std::cout << c << std::endl; }