C++当代教程五

1. #pragma once
2. _Pragma("once")
4. # C/C++混合编程
5. #ifdef __cplusplus
6. extern "C" {
7. #endif
8. // 一些c代码
9. #ifdef __cplusplus
10. }
11. #endif
13. # 继承构造
14. struct A
15. {
16.   A(int i) {}
17.   A(double d,int i){}
18.   A(float f,int i,const char* c){}
19.   //...等等系列的构造函数版本
20. }；
21. old:
22. struct B:A
23. {
24.   B(int i):A(i){}
25.   B(double d,int i):A(d,i){}
26.   B(folat f,int i,const char* c):A(f,i,e){}
27.   //......等等好多个和基类构造函数对应的构造函数
28. }；
29. new:
30. struct B:A
31. {
32.   using A::A;
33.   //关于基类各构造函数的继承一句话搞定
34.   //......
35. }；
37. #regex
38. std::regex base_regex("([a-z]+)\\.txt");
39. std::smatch base_match;
40. for(const auto &fname: fnames) {
41.     if (std::regex_match(fname, base_match, base_regex)) {
42.         // sub_match 的第一个元素匹配整个字符串
43.         // sub_match 的第二个元素匹配了第一个括号表达式
44.         if (base_match.size() == 2) {
45.             std::string base = base_match[1].str();
46.             std::cout << "sub-match[0]: " << base_match[0].str() << std::endl;
47.             std::cout << fname << " sub-match[1]: " << base << std::endl;
48.         }
49.     }
50. }
52. #Variadic templates
54. // C++11
55. template <typename First, typename... Args>
56. auto sum(const First first, const Args... args) -> decltype(first) {
57.   const auto values = {first, args...};
58.   return std::accumulate(values.begin(), values.end(), First{0});
59. }
61. // C++17
62. template <typename... Args>
63. auto sum(Args... args) {
64.     // Unary folding.
65.     return (... + args);
66. }
68. template <typename... Args>
69. bool logicalAnd(Args... args) {
70.     // Binary folding.
71.     return (true && ... && args);
72. }
73. bool b = true;
74. bool& b2 = b;
75. logicalAnd(b, b2, true); // == true
77. #Inline namespaces
78. namespace Program {
79.   namespace Version1 {
80.     int getVersion() { return 1; }
81.     bool isFirstVersion() { return true; }
82.   }
83.   inline namespace Version2 {
84.     int getVersion() { return 2; }
85.   }
86. }
88. int version {Program::getVersion()};              // Uses getVersion() from Version2
89. int oldVersion {Program::Version1::getVersion()}; // Uses getVersion() from Version1
90. bool firstVersion {Program::isFirstVersion()};    // Does not compile when Version2 is added
92. # std::move temp
93. struct Bar {
94.     int a = 1;
95. };
97. struct Foo {
98.     Bar getBar() & { return bar; }
99.     Bar getBar() const& { return Bar{}; }
100.     Bar getBar() && { return std::move(Bar{}); }
101. private:
102.     Bar bar;
103. };
105. Foo foo;
106. auto&& ref = foo.getBar();
107. ref.a = 10;
109. # Nested namespaces
110. namespace A::B::C {
111.   int i;
112. }
114. # __has_include
115. #ifdef __has_include
116. #  if __has_include(<optional>)
117. #    include <optional>
118. #    define have_optional 1
119. #  elif __has_include(<experimental/optional>)
120. #    include <experimental/optional>
121. #    define have_optional 1
122. #    define experimental_optional
123. #  else
124. #    define have_optional 0
125. #  endif
126. #endif
128. # std::invoke
129. template <typename Callable>
130. class Proxy {
131.   Callable c_;
133. public:
134.   Proxy(Callable c) : c_{ std::move(c) } {}
136.   template <typename... Args>
137.   decltype(auto) operator()(Args&&... args) {
138.     // ...
139.     return std::invoke(c_, std::forward<Args>(args)...);
140.   }
141. };
143. const auto add = [](int x, int y) { return x + y; };
144. Proxy p{ add };
145. p(1, 2); // == 3
147. # std::clamp limitRange
148. std::clamp(0, -1, 1, std::less<>{}); // == 0
150. # std::reduce  
151. const std::array<int, 3> a{ 1, 2, 3 };
152. std::reduce(std::cbegin(a), std::cend(a)); // == 6  default binary operation is std::plus
153. // Using a custom binary op:
154. std::reduce(std::cbegin(a), std::cend(a), 1, std::multiplies<>{}); // == 6
156. const std::array<int, 3> b{ 1, 2, 3 };
157. const auto product_times_ten = [](const auto a, const auto b) { return a * b * 10; };
158. std::transform_reduce(std::cbegin(a), std::cend(a), std::cbegin(b), 0, std::plus<>{}, product_times_ten); // == 140
160. # std::inclusive_scan
161. const std::array<int, 3> a{ 1, 2, 3 };
163. std::inclusive_scan(std::cbegin(a), std::cend(a),
164.     std::ostream_iterator<int>{ std::cout, " " }, std::plus<>{}); // 1 3 6
166. std::exclusive_scan(std::cbegin(a), std::cend(a),
167.     std::ostream_iterator<int>{ std::cout, " " }, 0, std::plus<>{}); // 0 1 3
169. const auto times_ten = [](const auto n) { return n * 10; };
171. std::transform_inclusive_scan(std::cbegin(a), std::cend(a),
172.     std::ostream_iterator<int>{ std::cout, " " }, std::plus<>{}, times_ten); // 10 30 60
174. std::transform_exclusive_scan(std::cbegin(a), std::cend(a),
175.     std::ostream_iterator<int>{ std::cout, " " }, 0, std::plus<>{}, times_ten); // 0 10 30
176.        
177. # GCD and LCM 公倍数
178. const int p = 9;
179. const int q = 3;
180. std::gcd(p, q); // == 3
181. std::lcm(p, q); // == 9
183. # std::not_fn
185. # C++20 Coroutines
186. generator<int> range(int start, int end) {
187.   while (start < end) {
188.     co_yield start;
189.     start++;
190.   }
192.   // Implicit co_return at the end of this function:
193.   // co_return;
194. }
196. for (int n : range(0, 10)) {
197.   std::cout << n << std::endl;
198. }
200. # concept
201. template <typename T>
202. concept unsigned_integral = integral<T> && !signed_integral<T>;
204. template <typename T>
205. concept callable = requires (T f) { f(); };
207. // `T` is a constrained type template parameter.
208. template <typename T>
209.   requires my_concept<T>
210. void f(T v);
212. # [[likely]] and [[unlikely]] attributes
213. switch (n) {
214. case 1:
215.   // ...
216.   break;
218. [[likely]] case 2:  // n == 2 is considered to be arbitrarily more
219.   // ...            // likely than any other value of n
220.   break;
221. }
223. int random = get_random_number_between_x_and_y(0, 3);
224. if (random > 0) [[likely]] {
225.   // body of if statement
226.   // ...
227. }
229. # constexpr virtual functions
230. struct X1 {
231.   virtual int f() const = 0;
232. };
234. struct X2: public X1 {
235.   constexpr virtual int f() const { return 2; }
236. };
238. # explicit(bool)
239. struct foo {
240.   // Specify non-integral types (strings, floats, etc.) require explicit construction.
241.   template <typename T>
242.   explicit(!std::is_integral_v<T>) foo(T) {}
243. };
245. # enum
246. enum class rgba_color_channel { red, green, blue, alpha };
248. std::string_view to_string(rgba_color_channel my_channel) {
249.   switch (my_channel) {
250.     using enum rgba_color_channel;
251.     case red:   return "red";
252.     case green: return "green";
253.     case blue:  return "blue";
254.     case alpha: return "alpha";
255.   }
256. }
258. # constinit
259. const char* g() { return "dynamic initialization"; }
260. constexpr const char* f(bool p) { return p ? "constant initializer" : g(); }
262. constinit const char* c = f(true); // OK
263. constinit const char* d = f(false); // ERROR: `g` is not constexpr, so `d` cannot be evaluated at compile-time.
265. # std::span
266. std::span<const int, 3>{ c.cbegin(), c.cend() }
268. # Bit operations
269. std::popcount(0u); // 0
270. std::popcount(1u); // 1
271. std::popcount(0b1111'0000u); // 4
273. # Math constants
274. std::numbers::pi; // 3.14159...
275. std::numbers::e; // 2.71828..
277. # starts_with and ends_with on strings
278. std::string str = "foobar";
279. str.starts_with("foo"); // true
280. str.ends_with("baz"); // false
282. # std::midpoint
283. std::midpoint(1, 3); // == 2
285. # std::to_array
286. int a[] = {1, 2, 3};
287. std::to_array(a); // returns `std::array<int, 3>`

复制代码

C++当代教程四_c++ float 转 string-CSDN博客

---

创作不易，小小的支持一下吧！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金