├── AutoObjectPool自动归还的对象池.cpp
├── CaseSwitch字符串大小写互换.cpp
├── CheckDuplicate判断数组重复元素.cpp
├── CheckTypeListUnique模板元编程TypeList判断重复元素.cpp
├── DoubleDispatch双分派.cpp
├── Fibonacci斐波那契数列.cpp
├── IntegerSort整数排序.cpp
├── IsPalindrome判断回文数.cpp
├── MetaQuickSort编译期快速排序（模板元编程）.cpp
├── NoRepeatNum去重复数字.cpp
├── NumberOf1Bits二进制1的个数.cpp
├── PrintPrimeNumber打印质数.cpp
├── PrivateAccess访问私有成员变量.cpp
├── QuickIndex模板元编程Typelist快速下标访问.cpp
├── ReplaceType类型替换（模板元编程）.cpp
├── ReverseBits32颠倒二进制位.cpp
├── TupleCartesian元祖的笛卡尔积.cpp
└── TupleHash元组的哈希函数.cpp


/AutoObjectPool自动归还的对象池.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <algorithm>
 3 | #include <vector>
 4 | #include <memory>
 5 | #include <mutex>
 6 | using namespace std;
 7 | 
 8 | template<class T> class ObjectPool {
 9 | private:
10 |     using Storage = std::pair<T, std::weak_ptr<void>>;
11 |     std::vector<const std::shared_ptr<Storage>> v;
12 |     std::mutex m;
13 | public:
14 |     std::shared_ptr<T> acquire() {
15 |         std::lock_guard<std::mutex> l(m);
16 |         const std::shared_ptr<std::shared_ptr<Storage>> keeper = std::make_shared<std::shared_ptr<Storage>>();
17 |         auto iter = v.end();
18 |         while((iter = std::find_if(v.begin(), v.end(), [](const std::shared_ptr<Storage> &s){ return s->second.lock() == nullptr; })) == v.end())
19 |             v.push_back(std::make_shared<Storage>());
20 | 	    (*iter)->second = keeper;
21 | 	    *keeper = *iter;
22 |         return std::shared_ptr<T>(keeper, &(*iter)->first);
23 |     }
24 | };
25 | 
26 | int main()
27 | {
28 |     std::shared_ptr<ObjectPool<std::string>> op = std::make_shared<ObjectPool<std::string>>();
29 |     auto a = op->acquire();
30 |     {
31 |         auto b = op->acquire(), c = op->acquire();
32 |         std::cout << a.get() << std::endl;
33 |         std::cout << b.get() << std::endl;
34 |         std::cout << c.get() << std::endl;
35 |     }
36 |     auto e = op->acquire();
37 |     std::cout << e.get() << std::endl;
38 |     *e = "still alive";
39 |     op = nullptr;
40 |     std::cout << *e << std::endl;
41 | }
42 | 


--------------------------------------------------------------------------------
/CaseSwitch字符串大小写互换.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream> // cin cout
 2 | #include <iterator> // istreambuf_iterator ostreambuf_iterator
 3 | #include <string> // toupper tolower
 4 | #include <algorithm> // transform
 5 | 
 6 | using namespace std;
 7 | int main()
 8 | {
 9 | 	// 1. 利用transform和流迭代器直接处理输入输出
10 | 	// 2. 利用按位异或的性质（源字符、大写、小写之中去掉两个重复的）
11 | 	// 3. 利用lambda表达式作为处理的函数对象
12 | 	transform(istreambuf_iterator<char>(cin), istreambuf_iterator<char>(), ostreambuf_iterator<char>(cout), [](char c) { return c ^ toupper(c) ^ tolower(c); });
13 | }


--------------------------------------------------------------------------------
/CheckDuplicate判断数组重复元素.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoeMod/MagicCpp/c741f6c2661a46f77b5687dacd900bb6cea3b3f6/CheckDuplicate判断数组重复元素.cpp


--------------------------------------------------------------------------------
/CheckTypeListUnique模板元编程TypeList判断重复元素.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <type_traits>
 3 | 
 4 | // C++17 std::conjunction does this... however I use just C++11
 5 | template<class...Args> auto SfinaeConjunction(decltype(Args(), std::true_type())...) -> std::true_type;
 6 | template<class...Args> auto SfinaeConjunction(...) -> std::false_type;
 7 | template<class...Args> struct Conjunction : decltype(SfinaeConjunction<Args...>(Args()...)) {};
 8 | 
 9 | // If all types are unique, Tag<T, ?> can be deduced. Sfinae based on that.
10 | template<class T, std::size_t Index> struct Tag {};
11 | template<class T, std::size_t Index> static auto SfinaeHelper(const Tag<T, Index> &) -> std::true_type;
12 | template<class T/* no need Index */> static auto SfinaeHelper(...) -> std::false_type;
13 | 
14 | template<class List, class Seq> struct CheckTypeListUniqueImpl;
15 | template<template<class...> class L, class...Args, std::size_t...I> struct CheckTypeListUniqueImpl<L<Args...>, std::index_sequence<I...>>
16 | {
17 | 	struct Foo : Tag<Args, I >... {};
18 | 	using type = Conjunction<decltype(SfinaeHelper<Args>( Foo{} ))...>;
19 | };
20 | 
21 | // just make_index_sequence and forward
22 | template<class List> struct CheckTypeListUnique;
23 | template<template<class...> class L, class...Args> struct CheckTypeListUnique<L<Args...>>
24 | 	: CheckTypeListUniqueImpl<L<Args...>, std::index_sequence_for<Args...>>::type {};
25 | 
26 | // simple test case
27 | template<class...> struct TypeList;
28 | int main()
29 | {
30 | 	using A = TypeList<int, char, float, double>;
31 | 	using B = TypeList<int, float, char, int>;
32 | 	std::cout << CheckTypeListUnique<A>::value << CheckTypeListUnique<B>::value << std::endl;
33 | }
34 | 


--------------------------------------------------------------------------------
/DoubleDispatch双分派.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoeMod/MagicCpp/c741f6c2661a46f77b5687dacd900bb6cea3b3f6/DoubleDispatch双分派.cpp


--------------------------------------------------------------------------------
/Fibonacci斐波那契数列.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <array>
 3 | #include <type_traits>
 4 | 
 5 | // 使用模板计算0~92的斐波那契数
 6 | template<size_t N> struct F : std::integral_constant<long long, F<N - 1>::value + F<N - 2>::value> {};
 7 | template<> struct F<0> : std::integral_constant<long long, 0ll> {};
 8 | template<> struct F<1> : std::integral_constant<long long, 1ll> {};
 9 | 
10 | // 将结果填充至数组
11 | template<size_t...I>
12 | constexpr std::array<long long, sizeof...(I)> buildArray(std::index_sequence<I...>)
13 | {
14 | 	return { F<I>::value... };
15 | }
16 | auto arr = buildArray(std::make_index_sequence<93>());
17 | 
18 | int main()
19 | {
20 | 	using namespace std;
21 | 	int i = 0;
22 | 	cin >> i;
23 | 	cout << arr[i] << endl;
24 | }


--------------------------------------------------------------------------------
/IntegerSort整数排序.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <iterator>
 3 | #include <algorithm>
 4 | #include <vector>
 5 | #include <set>
 6 | 
 7 | int main()
 8 | {
 9 | 	/*std::vector<int> v((std::istream_iterator<int>(std::cin)), (std::istream_iterator<int>())); // 输入数据到数组（按Ctrl+Z结束）
10 | 	std::sort(v.begin(), v.end()); // 对数组从小到大排序*/
11 | 	
12 | 	std::multiset<int> v((std::istream_iterator<int>(std::cin)), (std::istream_iterator<int>())); // 利用set自动排序
13 | 	std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " ")); // 从数组输出数据
14 | }
15 | 


--------------------------------------------------------------------------------
/IsPalindrome判断回文数.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <algorithm>
 4 | #include <iterator>
 5 | using namespace std;
 6 | 
 7 | // https://leetcode-cn.com/problems/palindrome-number/
 8 | 
 9 | bool isPalindrome(int x)
10 | {
11 | 	auto str = std::to_string(x);
12 | 	return std::mismatch(str.cbegin(), str.cend(), str.crbegin()).first == str.cend();
13 | }
14 | 
15 | int main()
16 | {
17 | 	uint32_t n = *istream_iterator<uint32_t>(cin);
18 | 	cout << isPalindrome(n) << endl;
19 | }


--------------------------------------------------------------------------------
/MetaQuickSort编译期快速排序（模板元编程）.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <tuple>
 3 | #include <type_traits>
 4 | 
 5 | template<template<class >class F> struct NotFn1
 6 | {
 7 | 	template<class T> struct type
 8 | 	{
 9 | 		static constexpr bool value = !F<T>::value;
10 | 	};
11 | };
12 | 
13 | template<class List, class Elem, template<class> class UnaryFunc> struct AppendIf;
14 | template<template<class...>class L, class...T, class Elem, template<class> class UnaryFunc> struct AppendIf<L<T...>, Elem, UnaryFunc>
15 | {
16 | 	using type = typename std::conditional<UnaryFunc<Elem>::value, L<T..., Elem>, L<T...>>::type;
17 | };
18 | 
19 | template<class List, template<class> class UnaryFunc> struct RemoveIf;
20 | template<template<class...>class L, class...AllElems, template<class> class UnaryFunc> struct RemoveIf<L<AllElems...>, UnaryFunc>
21 | {
22 | 	template<class NewList, class...Rest> struct filter;
23 | 	template<class...Elems> struct filter<L<Elems...>>
24 | 	{
25 | 		using type = L<Elems...>;
26 | 	};
27 | 	template<class...Elems, class First, class...Rest> struct filter<L<Elems...>, First, Rest...>
28 | 	{
29 | 		using type = typename filter<typename AppendIf<L<Elems...>, First, UnaryFunc>::type, Rest...>::type;
30 | 	};
31 | 	using type = typename filter<L<>, AllElems...>::type;
32 | };
33 | 
34 | template<class List, template<class> class DivideFunc> struct Partition
35 | {
36 | 	using left = typename RemoveIf<List, DivideFunc>::type;
37 | 	using right = typename RemoveIf<List, NotFn1<DivideFunc>::template type>::type;
38 | 	using type = std::pair<left, right>;
39 | };
40 | 
41 | template<class...Lists> struct ListCat;
42 | template<class First> struct ListCat<First>
43 | {
44 | 	using type = First;
45 | };
46 | template<template<class...>class L, class...A, class...B, class...Rest> struct ListCat<L<A...>, L<B...>, Rest...>
47 | {
48 | 	using type = typename ListCat<L<A..., B...>, Rest...>::type;
49 | };
50 | 
51 | template<class List, template<class, class> class CompareFunc> struct QSort;
52 | template<template<class...>class L, class First, class...Rest, template<class, class> class CompareFunc> struct QSort<L<First, Rest...>, CompareFunc>
53 | {
54 | 	template<class T>
55 | 	struct BindDivided : CompareFunc<First, T> {};
56 | 	using divided = Partition<L<Rest...>, NotFn1<BindDivided>::template type>;
57 | 	using type = typename ListCat<
58 | 			typename QSort<typename divided::left, CompareFunc>::type,
59 | 	        L<First>,
60 | 			typename QSort<typename divided::right, CompareFunc>::type
61 | 	>::type;
62 | };
63 | template<template<class...>class L, template<class, class> class CompareFunc> struct QSort<L<>, CompareFunc>
64 | {
65 | 	using type = L<>;
66 | };
67 | 
68 | template<class A, class B> struct SizeofCompare : std::integral_constant<bool, (sizeof(A) < sizeof(B))> {};
69 | 
70 | int main()
71 | {
72 | 	using A = std::tuple<int, double, char, bool, void *>;
73 | 	using B = typename QSort<A, SizeofCompare>::type;
74 |     std::cout << typeid(B).name() << std::endl;
75 | }


--------------------------------------------------------------------------------
/NoRepeatNum去重复数字.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoeMod/MagicCpp/c741f6c2661a46f77b5687dacd900bb6cea3b3f6/NoRepeatNum去重复数字.cpp


--------------------------------------------------------------------------------
/NumberOf1Bits二进制1的个数.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <iterator>
 3 | using namespace std;
 4 | 
 5 | // https://leetcode-cn.com/problems/number-of-1-bits/
 6 | 
 7 | int hammingWeight(uint32_t n) 
 8 | {
 9 | 	n = (n & 0x55555555) + ((n >> 1) & 0x55555555);
10 | 	n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
11 | 	n = (n & 0x0F0F0F0F) + ((n >> 4) & 0x0F0F0F0F);
12 | 	n = (n & 0x00FF00FF) + ((n >> 8) & 0x00FF00FF);
13 | 	n = (n & 0x0000FFFF) + ((n >> 16) & 0x0000FFFF);
14 | 	return n;
15 | }
16 | 
17 | int main()
18 | {
19 | 	uint32_t n = *istream_iterator<uint32_t>(cin);
20 | 	cout << hammingWeight(n) << endl;
21 | }


--------------------------------------------------------------------------------
/PrintPrimeNumber打印质数.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <array>
 3 | #include <type_traits>
 4 | 
 5 | constexpr size_t log2(size_t N)
 6 | {
 7 | 	return N == 1 ? 0 : log2(N >> 1) + 1;
 8 | }
 9 | 
10 | template<class...Seq> struct SequenceCat;
11 | template<class A> struct SequenceCat<A> { using type = A; };
12 | template<size_t...I1, size_t...I2> struct SequenceCat<std::index_sequence<I1...>, std::index_sequence<I2...>>
13 | {
14 | 	using type = std::index_sequence<I1..., I2...>;
15 | };
16 | template<class A, class B, class...Rest> struct SequenceCat<A, B, Rest...>
17 | 		: SequenceCat<
18 | 			typename SequenceCat<A, B>::type,
19 | 			typename SequenceCat<Rest...>::type
20 | 		>{};
21 | 
22 | template<class Seq, template<size_t> class F> struct SequenceRemoveIf;
23 | template<size_t...I, template<size_t> class F> struct SequenceRemoveIf <std::index_sequence<I...>, F>
24 | 		: SequenceCat<
25 | 			typename std::conditional<
26 | 				F<I>::value,
27 | 				std::index_sequence<>,
28 | 				std::index_sequence<I>
29 | 			>::type...
30 | 		>{};
31 | template<template<size_t> class F> struct SequenceRemoveIf <std::index_sequence<>, F>
32 | {
33 | 	using type = std::index_sequence<>;
34 | };
35 | 
36 | template<class Seq, size_t N> struct SequenceAdd;
37 | template<size_t...I, size_t N> struct SequenceAdd<std::index_sequence<I...>, N>
38 | {
39 | 	using type = std::index_sequence<(I + N)...>;
40 | };
41 | 
42 | template<size_t N> struct MakePrimeSequence
43 | {
44 | 	template<class, class> struct Process;
45 | 	template<class Seq, size_t First, size_t...Rest> struct Process<Seq, std::index_sequence<First, Rest...>>
46 | 	{
47 | 		template<size_t X> struct lambda : std::integral_constant <bool, (X < 2) || (X > First && X % First == 0)> {};
48 | 
49 | 		using type = typename Process<
50 | 				typename SequenceRemoveIf<Seq, lambda>::type,
51 | 				typename SequenceRemoveIf<std::index_sequence<Rest...>, lambda>::type
52 | 			>::type;
53 | 	};
54 | 	template<class Seq> struct Process<Seq, std::index_sequence<>>
55 | 	{
56 | 		using type = Seq;
57 | 	};
58 | 
59 | 	using type = typename Process<
60 | 			std::make_index_sequence<N>,
61 | 			typename SequenceAdd<std::make_index_sequence<(1 << (log2(N) / 2 + 1)) - 2>, 2>::type
62 | 			>::type;
63 | };
64 | 
65 | template<size_t...I>
66 | constexpr auto SequenceToArray(std::index_sequence<I...>) -> std::array<size_t, sizeof...(I)>
67 | {
68 | 	return {I...};
69 | }
70 | 
71 | constexpr size_t N = 2000;
72 | constexpr auto PrimeTable = SequenceToArray(typename MakePrimeSequence<N>::type());
73 | 
74 | int main()
75 | {
76 | 	for(auto i : PrimeTable)
77 | 		std::cout << i << std::endl;
78 | 	return 0;
79 | }
80 | 


--------------------------------------------------------------------------------
/PrivateAccess访问私有成员变量.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | class A {
 4 | private:
 5 |     int val = 0;
 6 | public:
 7 |     virtual int get() const {
 8 |         return val;
 9 |     }
10 | };
11 | 
12 | constexpr int A::* get_private();
13 | template <int A::* Ptr> struct hack_a {
14 |     friend constexpr int A::* get_private() { return Ptr; }
15 | };
16 | template struct hack_a<&A::val>;
17 | 
18 | int main() {
19 |     A a;
20 |     constexpr int A::* p = get_private();
21 |     std::cout << a.get() << std::endl;
22 |     a.*p = 233;
23 |     std::cout << a.get() << std::endl;
24 | }


--------------------------------------------------------------------------------
/QuickIndex模板元编程Typelist快速下标访问.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <type_traits>
 3 | 
 4 | namespace Dalao {
 5 |     
 6 |     template<class T> struct type_identity { using type = T; };
 7 |     template<class Seq> struct MakeIndexFinder;
 8 |     template<size_t...I> struct MakeIndexFinder<std::index_sequence<I...>>
 9 |     {
10 |         template<class T> type_identity<T> operator()(decltype(I, void()) *..., T *, ...);
11 |     };
12 |     template<size_t N, class List> struct ListFind;
13 |     template<size_t N, template<class...>class L, class...Ts> struct ListFind<N, L<Ts...>>
14 |     : decltype( MakeIndexFinder<std::make_index_sequence<N>>()(typename type_identity<Ts *>::type()...) ) {};
15 |     
16 | }
17 | 
18 | namespace Modern {
19 |     
20 |     template<size_t I, class T> struct Indexed { using type = T; };
21 |     template<class...Ts> struct MakeIndexFinder
22 |     {
23 |         template<class Seq> struct impl;
24 |         template<size_t...I> struct impl<std::index_sequence<I...>> : Indexed<I, Ts>... {};
25 |         using type = impl<std::index_sequence_for<Ts...>>;
26 |     };
27 |     template<size_t N, class T> auto ListFindHelper(const Indexed<N, T> &) -> Indexed<N, T>;
28 |     template<size_t N, class List> struct ListFind;
29 |     template<size_t N, template<class...>class L, class...Ts> struct ListFind<N, L<Ts...>>
30 |     : decltype(ListFindHelper<N>(typename MakeIndexFinder<Ts...>::type())) {};
31 |     
32 | }
33 | 
34 | namespace Naive {
35 |     
36 |     template<size_t N, class List> struct ListFind;
37 |     template<size_t N, template<class...>class L, class First, class...Rest> struct ListFind<N, L<First, Rest...>>
38 |     : ListFind<N - 1, L<Rest...>> {};
39 |     template<template<class...>class L, class First, class...Rest> struct ListFind<0, L<First, Rest...>>
40 |     {
41 |         using type = First;
42 |     };
43 |     
44 | }
45 | 
46 | // Make some test case
47 | template<class Seq> struct MakeTypelist;
48 | template<size_t...I> struct MakeTypelist<std::index_sequence<I...>>
49 | {
50 |     using type = std::tuple<std::integral_constant<size_t, I>...>;
51 | };
52 | int main()
53 | {
54 |     using A = MakeTypelist<std::make_index_sequence<65535>>::type;
55 |     
56 | #define X 1
57 |     
58 | #if X == 1
59 |     using B = Dalao::ListFind<255, A>::type;
60 | #elif X == 2
61 |     using B = Modern::ListFind<255, A>::type;
62 | #else
63 |     using B = Naive::ListFind<255, A>::type;
64 | #endif
65 |     std::cout << typeid(B).name() << std::endl;
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/ReplaceType类型替换（模板元编程）.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | template<class T>
 4 | struct identity
 5 | {
 6 | 	using type = T;
 7 | };
 8 | 
 9 | template<class c, class x, class y>
10 | struct replace_type : identity<c> {};
11 | 
12 | template<class x, class y>
13 | struct replace_type<x, x, y> : identity<y> {};
14 | 
15 | // functions with x
16 | template<class x, class y, class Return, class...Args>
17 | struct replace_type<Return(Args...), x, y>
18 | {
19 | 	using type = typename replace_type<Return, x, y>::type(typename replace_type<Args, x, y>::type...);
20 | };
21 | 
22 | // C++17
23 | #if __cplusplus >= 201703L
24 | template<class x, class y, class Return, class...Args>
25 | struct replace_type<Return(*)(Args...) noexcept, x, y>
26 | {
27 | 	using type = typename replace_type<Return, x, y>::type (*) (typename replace_type<Args, x, y>::type...) noexcept;
28 | };
29 | #endif
30 | 
31 | // template class with x
32 | template<class x, class y, template<class...A> class obj, class...Args>
33 | struct replace_type<obj<Args...>, x, y>
34 | {
35 | 	using type =  obj<typename replace_type<Args, x, y>::type...>;
36 | };
37 | 
38 | template<class c, class x, class y, size_t i>
39 | struct replace_type<c [i], x, y>
40 | {
41 | 	using type = typename replace_type<c, x, y>::type [i];
42 | };
43 | 
44 | template<class c, class x, class y>
45 | struct replace_type<const c, x, y> : identity<const typename replace_type<c, x, y>::type> {};
46 | 
47 | template<class c, class x, class y>
48 | struct replace_type<c *, x, y> : identity<typename replace_type<c, x, y>::type *> {};
49 | 
50 | template<class c, class x, class y>
51 | struct replace_type<c &, x, y> : identity<typename replace_type<c, x, y>::type &> {};
52 | 
53 | template<class c, class x, class y>
54 | struct replace_type<c &&, x, y> : identity<typename replace_type<c, x, y>::type &&> {};
55 | 
56 | int main()
57 | {
58 | 	std::cout << typeid(replace_type<int (*)(), int, float> ::type).name() << std::endl;
59 | }


--------------------------------------------------------------------------------
/ReverseBits32颠倒二进制位.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <iterator>
 3 | using namespace std;
 4 | 
 5 | // https://leetcode-cn.com/problems/reverse-bits/
 6 | 
 7 | uint32_t reverseBits(uint32_t n)
 8 | {
 9 | 	n = ((n & 0x55555555) << 1) | ((n & 0xAAAAAAAA) >> 1);
10 | 	n = ((n & 0x33333333) << 2) | ((n & 0xCCCCCCCC) >> 2);
11 | 	n = ((n & 0x0F0F0F0F) << 4) | ((n & 0xF0F0F0F0) >> 4);
12 | 	n = ((n & 0x00FF00FF) << 8) | ((n & 0xFF00FF00) >> 8);
13 | 	n = ((n & 0x0000FFFF) << 16) | ((n & 0xFFFF0000) >> 16);
14 | 	return n;
15 | }
16 | 
17 | int main()
18 | {
19 | 	uint32_t n = *istream_iterator<uint32_t>(cin);
20 | 	cout << reverseBits(n) << endl;
21 | }


--------------------------------------------------------------------------------
/TupleCartesian元祖的笛卡尔积.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <tuple>
 3 | 
 4 | template<class Tuple1, class Tuple2>
 5 | constexpr auto cart_impl(Tuple1&& lhs, Tuple2&& rhs, std::index_sequence<0>, 
 6 | 	typename std::enable_if<(std::tuple_size<typename std::decay<Tuple1>::type>::value == std::tuple_size<typename std::decay<Tuple2>::type>::value == 1)>::type * = nullptr)
 7 | {
 8 | 	using T1 = typename std::tuple_element<0, typename std::decay<Tuple1>::type >::type;
 9 | 	using T2 = typename std::tuple_element<0, typename std::decay<Tuple2>::type >::type;
10 | 	return std::tuple<std::pair<T1, T2>>(std::pair<T1, T2>(std::get<0>(std::forward<Tuple1>(lhs)), std::get<0>(std::forward<Tuple2>(rhs))));
11 | }
12 | 
13 | template<class T, class Tuple2, std::size_t...I2>
14 | constexpr auto cart_impl(const std::tuple<T>& lhs, Tuple2&& rhs, std::index_sequence<I2...>, 
15 | 	typename std::enable_if<std::tuple_size<typename std::decay<Tuple2>::type>::value != 1>::type * = nullptr)
16 | {
17 | 	return std::tuple_cat(cart_impl(
18 | 		lhs, 
19 | 		std::tuple<typename std::tuple_element<I2, typename std::decay<Tuple2>::type>::type>(std::get<I2>(std::forward<Tuple2>(rhs))), 
20 | 		std::index_sequence<0>()
21 | 	)...);
22 | }
23 | 
24 | template<class Tuple1, class Tuple2, std::size_t...I1>
25 | constexpr auto cart_impl(Tuple1&& lhs, Tuple2&& rhs, std::index_sequence<I1...>, 
26 | 	typename std::enable_if<std::tuple_size<typename std::decay<Tuple1>::type>::value != 1>::type * = nullptr)
27 | {
28 | 	return std::tuple_cat(cart_impl(
29 | 		std::tuple<typename std::tuple_element<I1, typename std::decay<Tuple1>::type>::type>(std::get<I1>(std::forward<Tuple1>(lhs))), 
30 | 		rhs, 
31 | 		std::make_index_sequence<std::tuple_size< typename std::decay<Tuple2>::type >::value>()
32 | 	)...);
33 | }
34 | 
35 | template<class Tuple1, class Tuple2>
36 | constexpr auto cart(Tuple1&& lhs, Tuple2&& rhs)
37 | {
38 | 	return cart_impl(std::forward<Tuple1>(lhs), std::forward<Tuple2>(rhs), std::make_index_sequence<std::tuple_size< typename std::decay<Tuple1>::type >::value>());
39 | }
40 | 
41 | int main()
42 | {
43 | 	int x = 1, y = 2, z = 3;
44 | 	auto tuple1 = std::tie(x, y, z);
45 | 	auto tuple2 = std::make_tuple("a", "b");
46 | 	auto tuple3 = cart(tuple2, tuple1);
47 | 	std::cout << typeid(tuple3).name() << std::endl;
48 | 	return 0;
49 | }


--------------------------------------------------------------------------------
/TupleHash元组的哈希函数.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <tuple>
 3 | 
 4 | using namespace std;
 5 | 
 6 | template<class...Args> struct hash<tuple<Args...>>
 7 | {
 8 | 	template<std::size_t...I>
 9 | 	std::size_t hash_impl(const tuple<Args...>& t, std::index_sequence<I...>) const
10 | 	{
11 | 		return (hash<Args>()(std::get<I>(t)) ^ ...);
12 | 	}
13 | 	std::size_t operator()(const tuple<Args...>& t) const
14 | 	{
15 | 		return hash_impl(t, std::index_sequence_for<Args...>());
16 | 	}
17 | };
18 | 
19 | int main()
20 | {
21 | 	auto t = std::make_tuple(123, 456);
22 | 	auto t2 = std::make_tuple(123, 456);
23 | 	std::cout << hash<decltype(t)>()(t) << std::endl;
24 | 	std::cout << hash<decltype(t)>()(t2) << std::endl;
25 | }


--------------------------------------------------------------------------------