Debian Codegraph @

yo/classtemplates/examples/sbind1.cc

raw
1 #include <iostream>
2 #include <tuple>
3
4 struct Cons1
5 {
6 Cons1()
7 {
8 std::cout << "cons1\n";
9 }
10
11 Cons1(Cons1 const &other)
12 {
13 std::cout << "cons1 copycons\n";
14 }
15
16 void fun() const
17 {
18 std::cout << "cons1 fun\n";
19 }
20 };
21
22
23 struct Cons2
24 {
25 Cons2()
26 {
27 std::cout << "cons2\n";
28 }
29
30 Cons2(Cons2 const &other)
31 {
32 std::cout << "cons2 copycons\n";
33 }
34
35 void fun() const
36 {
37 std::cout << "cons2 fun\n";
38 }
39 };
40
41 class Data
42 {
43 Cons1 d_cons1;
44 Cons2 d_cons2;
45
46 public:
47 Cons1 getCons() const
48 {
49 std::cout << "getCons():\n";
50 return d_cons1;
51 }
52 Cons1 const &cons1() const
53 {
54 std::cout << "cons1():\n";
55 return d_cons1;
56 }
57 Cons2 const &cons2() const
58 {
59 std::cout << "cons2():\n";
60 return d_cons2;
61 }
62
63 // template <size_t Nr>
64 // auto get() const
65 // {
66 // if constexpr (Nr == 0)
67 // return getCons();
68 //
69 // if constexpr (Nr == 1)
70 // return cons1();
71 //
72 // if constexpr (Nr == 2)
73 // return cons2();
74 //
75 // static_assert(Nr >= 0 and Nr < 3);
76 // }
77 };
78
79 //instead of defining get as class member: it can also be defined
80 // outside of the class:
81 //
82 // template <size_t Nr>
83 // auto get(Data const &data)
84 // {
85 // if constexpr (Nr == 0)
86 // return data.getCons();
87 //
88 // if constexpr (Nr == 1)
89 // return data.cons1();
90 //
91 // if constexpr (Nr == 2)
92 // return data.cons2();
93 //
94 // static_assert(Nr >= 0 and Nr < 3);
95 // }
96
97 // the return types can also be more precisely defined:
98 template <size_t Nr>
99 decltype(auto) get(Data const &data)
100 {
101 if constexpr (Nr == 0)
102 return data.getCons();
103
104 if constexpr (Nr == 1)
105 // return static_cast<Cons1 const &>(data.cons1());
106 return data.cons1();
107
108 if constexpr (Nr == 2)
109 // return static_cast<Cons2 const &>(data.cons2());
110 return data.cons2();
111
112 static_assert(Nr >= 0 and Nr < 3);
113 }
114
115 // in which case the tuple_element calls get(data):
116
117 template<size_t Nr>
118 struct std::tuple_element<Nr, Data>
119 {
120 using type = decltype( get<Nr>( declval<Data>() ) );
121 };
122
123
124 // same as below, explicitly inside namespace std:
125 template<>
126 struct std::tuple_size<Data>
127 {
128 public:
129 static size_t const value = 3;
130 };
131
132 namespace std
133 {
134
135 //template<>
136 //class tuple_size<Data>: public integral_constant<size_t, 3>
137 //{};
138 //
139 // Same:
140 //
141 //template<>
142 //struct tuple_size<Data>
143 //{
144 // static size_t const value = 3;
145 //};
146
147
148 //template<size_t Nr>
149 //class tuple_element<Nr, Data>
150 //{
151 // public:
152 // using type = decltype(declval<Data>().get<Nr>());
153 //};
154
155
156 }
157
158 using namespace std;
159
160 int main()
161 {
162 Data data;
163
164 cout << "\n------\n\n";
165
166 // copies data
167 // auto [ a, b, c ] = data; // here copy constructors are called,
168
169 // uses data
170 auto const &[ a, b, c ] = data; // here copy constructors are called,
171 // in all cases, a, b and c themselves are references.
172
173
174 cout << "\n------\n\n";
175
176 a.fun();
177
178 cout << "\n------\n\n";
179
180 b.fun();
181
182 cout << "\n------\n\n";
183
184 c.fun();
185 }