{"id":15047736,"url":"https://github.com/mq-b/loser-homework","last_synced_at":"2025-05-15T00:09:16.910Z","repository":{"id":185916939,"uuid":"674314687","full_name":"Mq-b/Loser-HomeWork","owner":"Mq-b","description":"卢瑟们的作业展示，答案讲解，以及一些C++知识","archived":false,"fork":false,"pushed_at":"2025-01-27T05:29:36.000Z","size":41588,"stargazers_count":716,"open_issues_count":5,"forks_count":138,"subscribers_count":10,"default_branch":"main","last_synced_at":"2025-04-06T17:08:08.136Z","etag":null,"topics":["cpp","cpp20","homework","loser","modern-cpp"],"latest_commit_sha":null,"homepage":"https://mq-b.github.io/Loser-HomeWork/","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Mq-b.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":"CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2023-08-03T16:32:24.000Z","updated_at":"2025-04-06T14:25:49.000Z","dependencies_parsed_at":null,"dependency_job_id":"377b2ebd-7ea8-41ff-a302-6e1f65c428cd","html_url":"https://github.com/Mq-b/Loser-HomeWork","commit_stats":{"total_commits":835,"total_committers":73,"mean_commits":"11.438356164383562","dds":0.6263473053892216,"last_synced_commit":"3d260f8749adcbf267846bbeadefdaa549765b40"},"previous_names":["mq-b/loser-homework"],"tags_count":7,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mq-b%2FLoser-HomeWork","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mq-b%2FLoser-HomeWork/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mq-b%2FLoser-HomeWork/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mq-b%2FLoser-HomeWork/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Mq-b","download_url":"https://codeload.github.com/Mq-b/Loser-HomeWork/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248782263,"owners_count":21160716,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cpp","cpp20","homework","loser","modern-cpp"],"created_at":"2024-09-24T21:03:59.726Z","updated_at":"2025-04-13T20:41:49.398Z","avatar_url":"https://github.com/Mq-b.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cdiv id=\"img\" align=center\u003e\n\n[![视频教程](https://img.shields.io/badge/%E8%A7%86%E9%A2%91%E6%95%99%E7%A8%8B-bilibili-cyan)](https://www.bilibili.com/video/BV1Zj411r7eP)\n[![QQ 群](https://img.shields.io/badge/QQ%E7%BE%A4-%E5%8D%A2%E7%91%9F%E5%B8%9D%E5%9B%BD-blue)](https://qm.qq.com/cgi-bin/qm/qr?k=X-ouAYdQzPDQGUR7R-vECHDpXb7Uihdm\u0026jump_from=webapi\u0026authKey=5XYoNIfb913mo5Ff3P1nOhVy1pJgCM4Q6wAykQ+rpiDQSRu+tCXMN6yGOkjxIIrl)\n[![知乎](https://img.shields.io/badge/%E7%9F%A5%E4%B9%8E-mq%E7%99%BD-yello)](https://www.zhihu.com/people/o4ze4r)\n[![youtube](https://img.shields.io/badge/video-YouTube-red)](https://www.youtube.com/channel/UCey35Do4RGewqr-6EiaCJrg)\n\n[![modern cpp](https://img.shields.io/badge/code-Modern%20C++-blue)](https://learn.microsoft.com/zh-cn/cpp/cpp/welcome-back-to-cpp-modern-cpp)\n[![cpp2b](https://img.shields.io/badge/std-C++20/23/26-yello)](https://zh.cppreference.com/w/cpp/compiler_support)\n[![gcc](https://img.shields.io/badge/compiler-GCC14-white)](https://gcc.gnu.org/onlinedocs/14.1.0/)\n[![msvc](https://img.shields.io/badge/compiler-MSVC19.37-white)](https://learn.microsoft.com/zh-cn/cpp/cpp)\n[![clang](https://img.shields.io/badge/compiler-clang18-white)](https://releases.llvm.org/18.1.8/tools/clang/docs/)\n\n\u003c/div\u003e\n\u003cdiv id=\"img\" align=center\u003e\n    \u003ca herf=\"https://zh.cppreference.com/w/cpp\"\u003e\u003cimg src=\"image/cpp.svg\" width=64px alt=\"cpp\"/\u003e\u003c/a\u003e\n\u003c/div\u003e\n\n\u003cdetails\u003e\n    \u003csummary\u003e目录\u003c/summary\u003e\n\n- [前言](#前言)\n- [`01` 实现管道运算符](#01-实现管道运算符)\n  + [运行结果](#运行结果)\n  + [群友提交](#群友提交-0)\n  + [标准答案](#标准答案-0)\n  + [解析](#解析-0)\n- [`02` 实现自定义字面量 `_f`](#02-实现自定义字面量-_f)\n  + [运行结果](#运行结果-1)\n  + [群友提交](#群友提交-1)\n  + [标准答案](#标准答案-1)\n  + [解析](#解析-1)\n- [`03` 实现 `print` 以及特化 `std::formatter`](#03-实现-print-以及特化-stdformatter)\n  + [运行结果](#运行结果-2)\n  + [群友提交](#群友提交-2)\n  + [标准答案](#标准答案-2)\n  + [解析](#解析-2)\n- [`04` 给定类模板修改，让其对每一个不同类型实例化有不同 ID](#04-给定类模板修改让其对每一个不同类型实例化有不同-id)\n  + [运行结果](#运行结果-3)\n  + [群友提交](#群友提交-3)\n  + [标准答案](#标准答案-3)\n- [`05` 实现 `scope_guard` 类型](#05-实现-scope_guard-类型)\n  + [运行结果](#运行结果-4)\n  + [群友提交](#群友提交-4)\n  + [标准答案](#标准答案-4)\n- [`06` 解释 `std::atomic` 初始化](#06-解释-stdatomic-初始化)\n  + [群友提交](#群友提交-5)\n  + [标准答案](#标准答案-5)\n- [`07` `throw new MyException`](#07-throw-new-myexception)\n  + [运行结果](#运行结果-5)\n  + [群友提交](#群友提交-6)\n  + [标准答案](#标准答案-6)\n- [`08` 定义`array`推导指引](#08-定义array推导指引)\n  + [运行结果](#运行结果-6)\n  + [群友提交](#群友提交-7)\n  + [标准答案](#标准答案-7)\n- [`09` 名字查找的问题](#09-名字查找的问题)\n  + [运行结果](#运行结果-7)\n  + [群友提交](#群友提交-8)\n  + [标准答案](#标准答案-8)\n- [`10` 遍历任意类数据成员](#10-遍历任意类数据成员)\n  + [运行结果](#运行结果-8)\n  + [群友提交](#群友提交-9)\n  + [标准答案](#标准答案-9)\n    - [`C++17` 写法](#c17-写法)\n    - [`C++20` 写法](#c20-写法)\n  + [补充说明](#补充说明-0)\n- [`11` `emplace_back()` 的问题](#11-emplace_back-的问题)\n  + [群友提交](#群友提交-10)\n  + [标准答案](#标准答案-10)\n- [`12` 实现`make_vector()`](#12-实现make_vector)\n  + [运行结果](#运行结果-9)\n  + [群友提交](#群友提交-11)\n  + [标准答案](#标准答案-11)\n    - [运行结果](#运行结果-10)\n- [`13` 关于 `return std::move`](#13-关于-return-stdmove)\n  + [群友提交](#群友提交-12)\n  + [标准答案](#标准答案-12)\n- [`14` 以特殊方法修改命名空间中声明的对象](#14-以特殊方法修改命名空间中声明的对象)\n  + [运行结果](#运行结果-11)\n  + [群友提交](#群友提交-13)\n  + [标准答案](#标准答案-13)\n    - [利用符号来解决](#利用符号来解决)\n    - [直接修改内存](#直接修改内存)\n    - [利用名字查找规则](#利用名字查找规则)\n- [`15` 表达式模板](#15-表达式模板)\n  + [群友提交](#群友提交-14)\n  + [标准答案](#标准答案-14)\n  + [解析](#解析-3)\n- [`16` 制造传递函数模板的宏](#16-制造传递函数模板的宏)\n  + [群友提交](#群友提交-15)\n  + [标准答案](#标准答案-15)\n\n\u003c/details\u003e\n\n\u003c!-- []: https://zh.cppreference.com/w/ --\u003e\n\n[Mq-b/Cookbook/7.6]: https://github.com/Mq-b/Cpp20-STL-Cookbook-src#76%E4%BD%BF%E7%94%A8%E6%A0%BC%E5%BC%8F%E5%BA%93%E6%A0%BC%E5%BC%8F%E5%8C%96%E6%96%87%E6%9C%AC\n[cpp/language/range-for]: https://zh.cppreference.com/w/cpp/language/range-for\n[cpp/utility/functional/function]: https://zh.cppreference.com/w/cpp/utility/functional/function\n[cpp/utility/tuple]: https://zh.cppreference.com/w/cpp/utility/tuple\n[cpp/ranges/range]: https://zh.cppreference.com/w/cpp/ranges/range\n[cpp/language/user_literal]: https://zh.cppreference.com/w/cpp/language/user_literal\n\n---\n\n## 前言\n\n**卢瑟们的作业展示。**\n\n[提交 PR](提交pr教程.md) 不应当更改当前 `README`，请将作业提交到 `src\\群友提交` 中，比如你要提交第一个作业：\n\n你应当在 `src\\群友提交\\第01题` 中创建一个自己的 `.md` 或 `.cpp` 文件，**文件名以自己交流群 ID 命名（或 GitHub 用户名都可，方便找到本人即可）**。\n\n答题的**一般要求**如下（题目额外要求也自行注意看）：\n\n1. 不更改 `main` 函数，不得使其不运行（意思别捞偏门）。\n2. 自行添加代码，在满足第一点的要求下，要能成功编译运行并与 **给出运行结果一致**。\n\n## `01` 实现管道运算符\n\n日期：**`2023/7/21`** 出题人：**`mq白`**\n\n给出代码：\n\n```cpp\nint main(){\n    std::vector v{1, 2, 3};\n    std::function f {[](const int\u0026 i) {std::cout \u003c\u003c i \u003c\u003c ' '; } };\n    auto f2 = [](int\u0026 i) {i *= i; };\n    v | f2 | f;\n}\n```\n\n### 运行结果\n\n```text\n1 4 9\n```\n\n- 难度：**★☆☆☆☆**\n\n\u003cdetails id=\"群友提交-0\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第01题)\n\n答题者：[**`andyli`**](src/群友提交/第01题/andyli.cpp)\n\n```cpp\n#include \u003calgorithm\u003e\n#include \u003cvector\u003e\n#include \u003cfunctional\u003e\n#include \u003ciostream\u003e\n\ntemplate \u003ctypename R, typename F\u003e\nauto operator|(R\u0026\u0026 r, F\u0026\u0026 f) {\n    for (auto\u0026\u0026 x: r)\n        f(x);\n    return r;\n}\nint main() {\n    std::vector v{1, 2, 3};\n    std::function f{[](const int\u0026 i) { std::cout \u003c\u003c i \u003c\u003c ' '; }};\n    auto f2 = [](int\u0026 i) { i *= i; };\n    v | f2 | f;\n}\n```\n\n\u003e 很常规，没啥问题。\n\n答题者：[**`mq松鼠`**](src/群友提交/第01题/mq松鼠.cpp)\n\n```cpp\n#include \u003ciostream\u003e\n#include \u003cvector\u003e\n#include \u003cfunctional\u003e\n\nauto operator | (std::vector\u003cint\u003e\u0026\u0026 v,std::function\u003cvoid(const int\u0026)\u003e f){\n    for(auto\u0026i:v){\n        f(i);\n    }\n    return v;\n}\nauto operator | (std::vector\u003cint\u003e\u0026 v,std::function\u003cvoid(int\u0026)\u003e f){\n    for(auto\u0026i:v){\n        f(i);\n    }\n    return v;\n}\nint main(){\n    std::vector v{1, 2, 3};\n    std::function f {[](const int\u0026 i) {std::cout \u003c\u003c i \u003c\u003c '\\n'; } };\n    auto f2 = [](int\u0026 i) {i *= i; };\n    v | f2 | f;\n}\n```\n\n\u003e 评价：闲的没事多写个重载，裱起来。\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-0\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\ntemplate\u003ctypename U, typename F\u003e\n    requires std::regular_invocable\u003cF, U\u0026\u003e//可加可不加，不会就不加\nstd::vector\u003cU\u003e\u0026 operator|(std::vector\u003cU\u003e\u0026 v1, F f) {\n    for (auto\u0026 i : v1) {\n        f(i);\n    }\n    return v1;\n}\n```\n\n**不使用模板**：\n\n```cpp\nstd::vector\u003cint\u003e\u0026 operator|(std::vector\u003cint\u003e\u0026 v1, const std::function\u003cvoid(int\u0026)\u003e\u0026 f) {\n    for (auto\u0026 i : v1) {\n        f(i);\n    }\n    return v1;\n}\n```\n\n不使用范围 `for`，使用 C++20 简写函数模板：\n\n```cpp\nstd::vector\u003cint\u003e\u0026 operator|(auto\u0026 v1, const auto\u0026 f) {\n    std::ranges::for_each(v1, f);\n    return v1;\n}\n```\n\n**各种其他答案的范式无非就是这些改来改去了，没必要再写。**\n\n\u003c/details\u003e\n\n\u003cdetails id=\"解析-0\"\u003e\n    \u003csummary\u003e解析\u003c/summary\u003e\n\n### 解析\n\n很明显我们需要重载管道运算符 |，根据我们的调用形式 `v | f2 | f`, 这种链式的调用，以及根据给出运行结果，我们可以知道，重载函数应当返回 v 的引用，并且 v 会被修改。\n`v | f2` 调用 `operator |`，operator | 中使用 f2 遍历了 v 中的每一个元素，然后返回 v 的引用，再 | f。\n\n```cpp\ntemplate\u003ctypename U, typename F\u003e\nrequires std::regular_invocable\u003cF, U\u0026\u003e //我们可以认为对模板形参U，F满足std::regular_invocable的约束\n```\n\n如果没接触过约束表达式，没关系，下面将简要的介绍。\n\nrequires 表达式如同一个返回 bool 的函数，而 U 和 F 作为类型填入 std::regular_invocable 的实参列表里，只要作为类型的 U、F 满足该表达式则返回 true；不满足则返回 false，称为“不满足约束”。不满足约束的类型自然不会执行后续的代码。\n\n而 [std::regular_invocable](https://zh.cppreference.com/w/cpp/concepts/invocable) 我们可以简单看成对类型 U 的每一个值，我们是否可以调用函数 F，即调用 `std::invoke` 。\n\n这就相当于我们在编译期对运行期做了想象，想象是否可以对 U 在运行期执行 F。如果可以那满足约束。\n\n而函数主体则极为简单\n\n```cpp\nstd::vector\u003cU\u003e\u0026 operator|(std::vector\u003cU\u003e\u0026 v1, const F f) {\n    for (auto\u0026 i : v1) {\n        f(i);\n    }\n    return v1;\n}\n```\n\n其中[范围表达式][cpp/language/range-for] `for (auto\u0026 i : v1)`，如同 `for(auto i=v.begin();i!=v.end();++i){f(*i)}`：我们对 *vector*（范围）中的每一个元素应用一次 **f** 函数。返回时照常返回 v1。\n\n如若不使用模板，则我们的形参列表得用 [std::function][cpp/utility/functional/function] 来接住我们使用的函数：\u003cbr/\u003e\n对范围中的每个成员应用 **f** 不需要返回值且需要对范围中的元素进行修改，所以第二个形参为 `std::function\u003cvoid(int\u0026)\u003e`。并且我们不需要对传进来的函数 **f** 进行修改与拷贝，所以加上 **const** 限定是个好习惯。\n\n同样的我们可以不使用范围 for 而是更简单的 `std::ranges::for_each(v1, f);` 即同上一样对范围 v1内的每个元素，应用一次函数 **f**。\n\n对于使用模板的形式，我们可以使用 C++20 的简写函数模板；简而言之，在函数形参列表中 auto 占位符会为模板形参列表追加一个虚设的模板形参。最开始的模板形式可以写成\n\n```cpp\nstd::vector\u003cint\u003e\u0026 operator|(auto\u0026 v1, const auto\u0026 f) \n```\n\n它和原形式相同。\n\n\u003c/details\u003e\n\n---\n\n## `02` 实现自定义字面量 `_f`\n\n日期：**`2023/7/22`** 出题人：**`mq白`**\n\n给出代码：\n\n```cpp\nint main(){\n    std::cout \u003c\u003c \"乐 :{} *\\n\"_f(5);\n    std::cout \u003c\u003c \"乐 :{0} {0} *\\n\"_f(5);\n    std::cout \u003c\u003c \"乐 :{:b} *\\n\"_f(0b01010101);\n    std::cout \u003c\u003c \"{:*\u003c10}\"_f(\"卢瑟\");\n    std::cout \u003c\u003c '\\n';\n    int n{};\n    std::cin \u003e\u003e n;\n    std::cout \u003c\u003c \"π：{:.{}f}\\n\"_f(std::numbers::pi_v\u003cdouble\u003e, n);\n}\n\n```\n\n### 运行结果\n\n```text\n乐 :5 *\n乐 :5 5 *\n乐 :1010101 *\n卢瑟******\n6\nπ：3.141593\n```\n\n- 难度：**★★☆☆☆**\n\n`6` 为输入，决定 $\\pi$ 的小数点后的位数，可自行输入更大或更小数字。\n提示：C++11 用户定义字面量、C++20 format 库。\n难度：**★★☆☆☆**\n\n\u003cdetails id=\"群友提交-1\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第02题)\n\n答题者：[**`andyli`**](src/群友提交/第02题/andyli.cpp)\n\n```cpp\n#include \u003cformat\u003e\n#include \u003ciostream\u003e\n#include \u003cstring_view\u003e\n#include \u003cstring\u003e\n\nnamespace impl {\n    struct Helper {\n        const std::string_view s;\n        Helper(const char* s, std::size_t len): s(s, len) {}\n        template \u003ctypename... Args\u003e\n        std::string operator()(Args\u0026\u0026... args) const {\n            return std::vformat(s, std::make_format_args(args...));\n        }\n    };\n} // namespace impl\nimpl::Helper operator\"\"_f(const char* s, std::size_t len) noexcept {\n    return {s, len};\n}\n\nint main() {\n    std::cout \u003c\u003c \"乐 :{} *\\n\"_f(5);\n    std::cout \u003c\u003c \"乐 :{0} {0} *\\n\"_f(5);\n    std::cout \u003c\u003c \"乐 :{:b} *\\n\"_f(0b01010101);\n    std::cout \u003c\u003c \"{:*\u003c10}\"_f(\"卢瑟\");\n    std::cout \u003c\u003c '\\n';\n    int n{};\n    std::cin \u003e\u003e n;\n    std::cout \u003c\u003c \"π：{:.{}f}\\n\"_f(std::numbers::pi_v\u003cdouble\u003e, n);\n}\n```\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-1\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\nconstexpr auto operator\"\"_f(const char* fmt, size_t) {\n    return[=]\u003ctypename... T\u003e(T\u0026\u0026... Args) { return std::vformat(fmt, std::make_format_args(Args...)); };\n}\n```\n\n\u003c/details\u003e\n\n\u003cdetails id=\"解析-1\"\u003e\n    \u003csummary\u003e解析\u003c/summary\u003e\n\n### 解析\n\n我们需要使用到 C++11 用户定义字面量，`\"\"_f` 正是[用户自定义字面量][cpp/language/user_literal]。\u003cbr/\u003e\n但**字面量运算符**（用户定义字面量所调用的函数被称为字面量运算符）的形参列表有一些限制，我们需要的是 `const char *, std::size_t` 这样的形参列表，恰好这是允许的；而字面量运算符的返回类型需要自定义，这个类型需要在内部重载 **`operator()`**，以满足上述字面量像函数一样调用的要求。\n\n我们一步一步来：\n\n```cpp\nvoid operator\"\"_test(const char* str, std::size_t){\n    std::cout \u003c\u003c str \u003c\u003c '\\n';\n}\n\n\"luse\"_test; //调用了字面量运算符，打印 luse\n\nstd::size_t operator\"\"_test(const char* , std::size_t len){\n    return len;\n}\n\nstd::size_t len = \"luse\"_test; //调用了字面量运算符，返回 luse 的长度 4\n```\n\n上面这段代码的两个使用示例展示了我们用户定义字面量的基本使用，尤其注意第二段，**返回值**。如果要做到像 `\"xxx\"_f(xxx)` 这样调用，就得在返回类型上做点手脚。\n\n```cpp\nstruct X{\n    std::size_t operator()(std::size_t n)const{\n        return n;\n    }\n};\n\nX operator\"\"_test(const char* , std::size_t){\n    return {};\n}\n\nstd::cout\u003c\u003c\"无意义\"_test(1); //打印 1\n```\n\n以上这段简单的代码很好的完成了我们需要的调用形式，那么是时候完成题目要求的功能了。最简单的方式是直接使用 C++20 format 库进行格式化。\n\n```cpp\nnamespace impl {\n    struct Helper {\n        const std::string_view s;\n        Helper(const char* s, std::size_t len): s(s, len) {}\n        template \u003ctypename... Args\u003e\n        std::string operator()(Args\u0026\u0026... args) const {\n            return std::vformat(s, std::make_format_args(args...));\n        }\n    };\n} // namespace impl\nimpl::Helper operator\"\"_f(const char* s, std::size_t len) noexcept {\n    return {s, len};\n}\n```\n\n`operator\"\"_f` 本身非常简单，只是用来把传入的参数（格式字符串）和长度，构造 `impl::Helper` 对象再返回。`Helper` 类型使用了一个 `string_view` 作为数据成员，存储了格式字符串，以供后面格式化使用。\n\n**重点只在于 `operator()`。** 它是一个变参模板，用来接取我们传入的任意类型和个数的参数，然后返回格式化后的字符串。\n\n这里用到的是 `std::vformat` 进行格式化，它的第一个参数是格式字符串，也就是我们要按照什么样的规则去格式化；第二个参数是要格式化的参数，但是我们没有办法直接进行形参包展开，它第二个参数的类型实际上是 `std::format_args`。\n我们必须使用 `std::make_format_args` 函数传入我们的参数，它会返回 `std::format_args` 类型，其实也就是相当于转换一下，合理。\n\n不过显然标准答案不是这样的，还能简化，直接让 `\"\"_f` 返回一个 lambda 表达式即可。\n\n\u003c/details\u003e\n\n---\n\n## `03` 实现 `print` 以及特化 `std::formatter`\n\n日期：**`2023/7/24`** 出题人：**`mq白`**\n\n实现一个`print`，如果你做了上一个作业，我相信这很简单。\n要求调用形式为:\n\n```cpp\nprint(格式字符串，任意类型和个数的符合格式字符串要求的参数)\n```\n\n```cpp\nstruct Frac {\n   int a, b;\n};\n```\n\n给出自定义类型`Frace`，要求支持\n\n```cpp\nFrac f{ 1,10 };\nprint(\"{}\", f);// 结果为1/10\n```\n\n### 运行结果\n\n```text\n1/10\n```\n\n- 难度：**★★★☆☆**\n\n禁止面向结果编程，使用宏等等方式，最多`B`（指评价），本作业主要考察和学习`format`库罢了。\n\n提示: **`std::formatter`**\n\n提交代码最好是网上编译了三个平台的截图，如：\n\n![图片](image/第03题/01展示.jpg)\n\n\u003cdetails id=\"群友提交-2\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第03题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-2\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\ntemplate\u003c\u003e\nstruct std::formatter\u003cFrac\u003e:std::formatter\u003cchar\u003e{\n    auto format(const auto\u0026 frac, auto\u0026 ctx)const{//const修饰是必须的\n        return std::format_to(ctx.out(), \"{}/{}\", frac.a, frac.b);\n    }\n};\nvoid print(std::string_view fmt,auto\u0026\u0026...args){\n    std::cout \u003c\u003c std::vformat(fmt, std::make_format_args(args...));\n}\n```\n\n我们只是非常简单的支持了**题目要求**的形式，给 `std::formatter` 进行特化，如果要支持比如那些 `{:6}` 之类的格式化的话，显然不行，这涉及到更多的操作。\n简单的特化以及 [`std::formatter`](cpp/utility/format/formatter) 支持的形式可以参见[**文档**](cpp/utility/format/formatter)。\n一些复杂的特化，up 之前也有写过，在 [**Cookbook**][Mq-b/Cookbook/7.6] 中，里面有对 [`std::ranges::range`][cpp/ranges/range] 和 [`std::tuple`][cpp/utility/tuple] 的特化，支持所有形式。\n\n\u003c/details\u003e\n\n\u003cdetails id=\"解析-0\"\u003e\n    \u003csummary\u003e解析\u003c/summary\u003e\n\n### 解析\n\n实现一个 print 很简单，我们只要按第二题的思路来就行了，一个格式化字符串，用 std::string_view 做第一个形参，另外需要任意参数和个数，使用形参包即可。\n\n```cpp\nvoid print(std::string_view fmt,auto\u0026\u0026...args){\n    std::cout \u003c\u003c std::vformat(fmt, std::make_format_args(args...));\n}\n```\n\n这样调用 `vformat`,返回 string,可以使用 cout 直接输出。\n\n而关于自定义 `std::formatter` 特化，我们需要知道的是：想要自定义 **std::formatter** 模板特化需要提供两个函数，**parse** 和 **format**。\n\n**parse** 用来处理格式说明，并且设置相关的成员变量，对于本题我们不需要麻烦地实现此成员函数；\u003cbr/\u003e\n我们选择继承 `std::formatter\u003cchar\u003e` 的 **parse** 函数，独立实现 **format** 函数。如果不了解此处模板特化的语法，请复习[模板特化](https://zh.cppreference.com/w/cpp/language/template_specialization)。\n\n```cpp\ntemplate\u003c\u003e\nstruct std::formatter\u003cFrac\u003e : std::formatter\u003cchar\u003e {\n    auto format(const auto\u0026 frac, auto\u0026 ctx)const{//const修饰是必须的\n        return std::format_to(ctx.out(), \"{}/{}\", frac.a, frac.b);\n    }\n};\n```\n\n我们同样使用 **auto** 作占位符的简写函数模板，对于 **format** 函数，首个参数为我们传递的自定义类，第二个参数（**ctx**）为我们要传递给 `std::format_to` 输出迭代器的格式字符串。\n\n在函数体中我们直接返回 `std::format_to()` 调用表达式的结果，此函数返回输出迭代器；返回值我们使用 **auto** 占位符进行返回值推导。\n\n在函数实参中，`ctx.out()` 即为输出迭代器，第二个参数为可转换为 `std::string_view` 或 `std::wstring_view`，而转换结果是常量表达式和 Args 的合法格式字符串。本题中我们填入我们需要的形式，即 `{}/{}`。\u003cbr/\u003e\n我们想要两个参数塞进 `{}`，就如我们使用 `printf(%d,x)` 一样；最后两个参数为“需要塞进 `{}` 的值”，即要格式化的参数。\n\n\u003c/details\u003e\n\n---\n\n## `04` 给定类模板修改，让其对每一个不同类型实例化有不同 ID\n\n日期：**`2023/7/25`** 出题人：[Adttil](https://github.com/Adttil)\n\n```cpp\n#include\u003ciostream\u003e\nclass ComponentBase{\nprotected:\n    static inline std::size_t component_type_count = 0;\n};\ntemplate\u003ctypename T\u003e\nclass Component : public ComponentBase{\npublic:\n    //todo...\n    //使用任意方式更改当前模板类，使得对于任意类型X，若其继承自Component\n\n    //则X::component_type_id()会得到一个独一无二的size_t类型的id（对于不同的X类型返回的值应不同）\n    //要求：不能使用std::type_info（禁用typeid关键字），所有id从0开始连续。\n};\nclass A : public Component\u003cA\u003e\n{};\nclass B : public Component\u003cB\u003e\n{};\nclass C : public Component\u003cC\u003e\n{};\nint main()\n{\n    std::cout \u003c\u003c A::component_type_id() \u003c\u003c std::endl;\n    std::cout \u003c\u003c B::component_type_id() \u003c\u003c std::endl;\n    std::cout \u003c\u003c B::component_type_id() \u003c\u003c std::endl;\n    std::cout \u003c\u003c A::component_type_id() \u003c\u003c std::endl;\n    std::cout \u003c\u003c A::component_type_id() \u003c\u003c std::endl;\n    std::cout \u003c\u003c C::component_type_id() \u003c\u003c std::endl;\n}\n```\n\n### 运行结果\n\n```text\n0\n1\n1\n0\n0\n2\n```\n\n- 难度:**★☆☆☆☆**\n\n提交应当给出多平台测试结果，如图：\n\n![图片](image/第04题/01展示.png)\n\n\u003cdetails id=\"群友提交-3\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第04题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-3\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\ntemplate\u003ctypename T\u003e\nclass Component : public ComponentBase{\npublic:\n    static std::size_t component_type_id(){\n        static std::size_t ID = component_type_count++;\n        return ID;\n    }\n};\n```\n\n分析：\n\n我们需要实现 `Component` 的静态成员函数 `component_type_id`。这是从给出代码得知的：\n\n```cpp\nclass A : public Component\u003cA\u003e\n{};\nA::component_type_id()\n```\n\n题目要求是每一个自定义类类型（假设是 X）继承 `Component\u003cX\u003e`，调用 `component_type_id()` 返回的是自己独一无二的 ID。其他的类型同理。\n\n解决题目之前我们需要强调一个知识点：\n\u003e C++ 的模板不是具体类型，实例化之后才是（即**函数模板不是函数，类模板不是类**），类模板的静态成员或静态成员函数也不属于模板，而是属于**实例化后的具体类型**，我们可以用一段代码来展示结论：\n\n```cpp\n#include \u003ciostream\u003e\n\ntemplate\u003ctypename T\u003e\nstruct Test{\n    inline static int n = 10;\n};\n\nint main(){\n    Test\u003cint\u003e::n = 1;\n    std::cout \u003c\u003c Test\u003cvoid\u003e::n \u003c\u003c '\\n';//10\n    std::cout \u003c\u003c Test\u003cint\u003e::n \u003c\u003c '\\n';//1\n}\n```\n\n这段代码很轻易的就展示了**静态数据成员属于模板实例化后的具体类型**。`Test\u003cvoid\u003e::n` 和 `Test\u003cint\u003e::n` 不是相同的 n，并且 `Test\u003cvoid\u003e` 和 `Test\u003cint\u003e` 也不是一种类型（静态成员函数同理）。\n\n所以我们的解法利用的是：不同的类型实例化 `Component` 类模板，也是不同的静态成员函数，静态成员函数里面的静态局部也都是唯一的，并且在第一次调用的时候才会初始化，后面就不会。\n\n\u003c/details\u003e\n\n---\n\n## `05` 实现 `scope_guard` 类型\n\n日期：**`2023/7/29`** 出题人：[Da'Inihlus](https://github.com/dynilath)\n\n要求实现 **`scope_guard`** 类型 （ 即支持传入任意可调用类型 , 析构的时候同时调用 ）。\n\n```cpp\n#include \u003ccstdio\u003e\n#include \u003ccassert\u003e\n\n#include \u003cstdexcept\u003e\n#include \u003ciostream\u003e\n#include \u003cfunctional\u003e\n\nstruct X {\n    X() { puts(\"X()\"); }\n    X(const X\u0026) { puts(\"X(const X\u0026)\"); }\n    X(X\u0026\u0026) noexcept { puts(\"X(X\u0026\u0026)\"); }\n    ~X() { puts(\"~X()\"); }\n};\n\nint main() {\n    {\n        // scope_guard的作用之一，是让各种C风格指针接口作为局部变量时也能得到RAII支持\n        // 这也是本题的基础要求\n        FILE * fp = nullptr;\n        try{\n            fp = fopen(\"test.txt\",\"a\");\n            auto guard = scope_guard([\u0026] {\n                fclose(fp);\n                fp = nullptr;\n            });\n\n            throw std::runtime_error{\"Test\"};\n        } catch(std::exception \u0026 e){\n            puts(e.what());\n        }\n        assert(fp == nullptr);\n    }\n    puts(\"----------\");\n    {\n        // 附加要求1，支持函数对象调用\n        struct Test {\n            void operator()(X* x) {\n                delete x;\n            }\n        } t;\n        auto x = new X{};\n        auto guard = scope_guard(t, x);\n    }\n    puts(\"----------\");\n    {\n        // 附加要求2，支持成员函数和std::ref\n        auto x = new X{};\n        {\n            struct Test {\n                void f(X*\u0026 px) {\n                    delete px;\n                    px = nullptr;\n                }\n            } t;\n            auto guard = scope_guard{\u0026Test::f, \u0026t, std::ref(x)};\n        }\n        assert(x == nullptr);\n    }\n}\n```\n\n### 运行结果\n\n```text\nTest\n----------\nX()\n~X()\n----------\nX()\n~X()\n```\n\n- 难度:**★★★★☆**（完全满足要求的情况下）\n\n\u003cdetails id=\"群友提交-4\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第05题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-4\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n- 使用 `std::function` 并擦除类型\n\n```cpp\nstruct scope_guard {\n    std::function\u003cvoid()\u003ef;\n    template\u003ctypename Func, typename...Args\u003e requires std::invocable\u003cFunc, std::unwrap_reference_t\u003cArgs\u003e...\u003e\n    scope_guard(Func\u0026\u0026 func, Args\u0026\u0026...args) :f{ [func = std::forward\u003cFunc\u003e(func), ...args = std::forward\u003cArgs\u003e(args)]() mutable {\n            std::invoke(std::forward\u003cstd::decay_t\u003cFunc\u003e\u003e(func), std::unwrap_reference_t\u003cArgs\u003e(std::forward\u003cArgs\u003e(args))...);\n        } }{}\n    ~scope_guard() { f(); }\n    scope_guard(const scope_guard\u0026) = delete;\n    scope_guard\u0026 operator=(const scope_guard\u0026) = delete;\n};\n```\n\n- 使用 `std::tuple`+`std::apply`\n\n```cpp\ntemplate\u003ctypename F, typename...Args\u003e\n    requires requires(F f, Args...args) { std::invoke(f, args...); }\nstruct scope_guard {\n    F f;\n    std::tuple\u003cArgs...\u003evalues;\n\n    template\u003ctypename Fn, typename...Ts\u003e\n    scope_guard(Fn\u0026\u0026 func, Ts\u0026\u0026...args) :f{ std::forward\u003cFn\u003e(func) }, values{ std::forward\u003cTs\u003e(args)... } {}\n    ~scope_guard() {\n        std::apply(f, values);\n    }\n    scope_guard(const scope_guard\u0026) = delete;\n};\n\ntemplate\u003ctypename F, typename...Args\u003e//推导指引非常重要\nscope_guard(F\u0026\u0026, Args\u0026\u0026...) -\u003e scope_guard\u003cstd::decay_t\u003cF\u003e, std::decay_t\u003cArgs\u003e...\u003e;\n```\n\n![第五题答案动画](video/第五题答案动画.gif)\n\n\u003c/details\u003e\n\n---\n\n## `06` 解释 `std::atomic` 初始化\n\n日期：**`2023/8/2`** 出题人：**`mq白`**\n\n```cpp\n#include \u003ciostream\u003e\n#include \u003catomic\u003e\nint main() {\n    std::atomic\u003cint\u003e n = 6;\n    std::cout \u003c\u003c n \u003c\u003c '\\n';\n}\n```\n\n解释，为什么以上[代码](https://godbolt.org/z/sfEzP8136)在 C++17 后可以通过编译，C++17 前不行？\n\n![图片](image/第06题/01展示.png)\n\n- 难度:**★★★☆☆**\n\n\u003cdetails id=\"群友提交-5\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第06题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-5\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n`std::atomic\u003cint\u003e n = 6` 中，由于 `6` 和 `std::atomic\u003cint\u003e` 不是同一类型（但是这里其实有一个用户定义转换序列，你可以简单的认为`6`可以隐式转换）。\n\n即调用转换构造函数：\n\n```cpp\nconstexpr atomic( T desired ) noexcept;\n```\n\n\u003e转换构造函数也会作为用户定义的转换序列中的一部分\n\n`6` 会调用转换构造函数，构造出一个临时的 atomic 对象用来**直接初始化 `n`**，即\n\n```cpp\nstd::atomic\u003cint\u003e n(std::atomic\u003cint\u003e(6))\n```\n\n在 **C++17 之前** 的版本，理所应当应该查找检测复制/移动 构造函数，满足要求才可以通过编译。但是：\n\n```cpp\natomic( const atomic\u0026 ) = delete;\n```\n\n实际上 atomic 的复制构造被删除（同时移动构造也被抑制生成了）。所以自然而然的不允许。\n\nC++17 的改动是：**复制消除变为强制要求**。\n纯右值表达式作为构造对象的参数，不会再调用移动构造，也不会去检测，而是原位构造。\n\u003e说句题外话，C++17后纯右值不可能再调用移动构造。没有移动构造或者复制构造不影响使用同类型纯右值初始化对象，如 `X x{X{}}`，即使移动/复制构造函数**都被 delete**，也无所谓，[`code`](https://godbolt.org/z/Kdncxcc3o)。\n\n\u003c/details\u003e\n\n---\n\n## `07` `throw new MyException`\n\n日期：**`2023/8/6`** 出题人：**`mq白`**\n\n给出代码:\n\n```cpp\nstruct MyException :std::exception {\n const char* data{};\n MyException(const char* s) :data(s) { puts(\"MyException()\"); }\n ~MyException() { puts(\"~MyException()\"); }\n const char* what()const noexcept { return data; }\n};\nvoid f2() {\n throw new MyException(\"new Exception异常....\");\n}\nint main(){\n    f2();\n}\n```\n\n\u003e 灵感来源自 **Java** 人写 **C++**\n\n在 `main` 函数中自行修改代码，接取 `f2()` 函数抛出的异常（`try catch`）。\n\n### 运行结果\n\n```text\nMyException()\nnew Exception异常....\n~MyException()\n```\n\n- 难度: **★☆☆☆☆**\n\n\u003e 某些 IDE 或者平台可能会将打印的异常信息标为红色放到第一行，即\n\u003e new Exception 异常.... 这句话也可能在第一行（一般终端运行不会，默认 vs 也无此功能）\n\n\u003cdetails id=\"群友提交-6\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第07题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-6\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\nint main() {\n    try {\n        f2();\n    }\n    catch (std::exception* e){\n        std::cerr \u003c\u003c std::unique_ptr\u003cstd::exception\u003e(e)-\u003ewhat() \u003c\u003c '\\n';\n    }\n}\n```\n\n实际上本题是用来讽刺将 Java 的写法带入到其他语言中，也就是很经典的：**Java 人写什么都是 Java**。\n只是看我们这道题，实际上你非要说 `new` 有什么不好，倒也没什么非常不行的地方，只是，没有理由自己多写一个 `delete` 表达式（或者包个智能指针）。\n\u003e 我希望不要有人开始幻想：`throw new MyException(\"new Exception 异常....\")`因为是 `throw` 一个指针类型，所以按指针传递，效率更高。不要让我看到这种逆天想法。如果你想到这一点，那不妨思考一下，构造临时对象的开销，以及使用 `new` 表达式？说实话挺无聊的问题，只是防止有人想到这些点，以及抬杠罢了。\n\n\u003c/details\u003e\n\n---\n\n## `08` 定义`array`推导指引\n\n日期：**`2023/8/12`** 出题人：**`mq白`**\n\n给出代码:\n\n```cpp\ntemplate\u003cclass Ty,size_t size\u003e\nstruct array {\n    Ty* begin() { return arr; };\n    Ty* end() { return arr + size; };\n    Ty arr[size];\n};\nint main() {\n    ::array arr{1, 2, 3, 4, 5};\n    for (const auto\u0026 i : arr) {\n        std::cout \u003c\u003c i \u003c\u003c ' ';\n    }\n}\n```\n\n要求**自定义推导指引**，不更改已给出代码，使得代码成功编译并满足运行结果。\n\n\u003e 提示：可参考[`std::array`](https://zh.cppreference.com/w/cpp/container/array)\n\n### 运行结果\n\n```text\n1 2 3 4 5 \n```\n\n- 难度: **★★★☆☆**\n\n\u003cdetails id=\"群友提交-7\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第08题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-7\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\ntemplate\u003cclass Ty, class...Args\u003e\n    requires (std::same_as\u003cTy, Args\u003e\u0026\u0026...)//不会这个C++20约束以及里面折叠表达的用法也可以不用\narray(Ty, Args...) -\u003e array\u003cTy, 1 + sizeof...(Args)\u003e;\n```\n\n本题的目的如你所见主要考察的是 **C++17 用户定义类模板推导指引**。但是我更多的其实我想表达的是：\n定义类模板推导指引和构造函数没什么直接的关联；如题目所示，我们的 `array` 是一个聚合类型，压根没有显式的用户定义构造函数，**没有显示的构造函数并不影响我们使用自定义的用户推导指引**。\n\n\u003e 如此强调只是因为大部分人对此有很多错误认知\n\n推导指引实际上是按照你构造器传入的东西，来进行的这种推导，我觉得我视频里说的已经很清楚了。\n\n\u003c/details\u003e\n\n---\n\n## `09` 名字查找的问题\n\n日期：**`2023/8/15`** 出题人：**`mq白`**\n\n```cpp\n#include\u003ciostream\u003e\n\ntemplate\u003cclass T\u003e\nstruct X {\n    void f()const { std::cout \u003c\u003c \"X\\n\"; }\n};\n\nvoid f() { std::cout \u003c\u003c \"全局\\n\"; }\n\ntemplate\u003cclass T\u003e\nstruct Y : X\u003cT\u003e {\n    void t()const {\n        this-\u003ef();\n    }\n    void t2()const {\n        f();\n    }\n};\n\nint main() {\n    Y\u003cvoid\u003ey;\n    y.t();\n    y.t2();\n}\n```\n\n给出以上代码，要求解释其运行结果。\n\n### 运行结果\n\n```text\nX\n全局\n```\n\n- 难度: **★★★☆☆**\n\n\u003e 本问题堪称经典，**在某著名 template 书籍也有提过**（虽然它完全没有讲清楚）。\n\u003e 并且从浅薄的角度来说，本题也可以让你向其他人证明加 **`this`** 访问类成员，和不加，是有很多区别的。\n\n提示：[**名字查找**](https://zh.cppreference.com/w/cpp/language/lookup)\n\n\u003cdetails id=\"群友提交-8\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第09题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-8\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n根据我们的提示 **名字查找**，我看大家多少都还是能查到一些东西。我们慢慢说吧，首先名字查找分为：**有限定** 名字查找，**无限定** 名字查找。\n\n\u003e 有限定名字查找指？\n\u003e\n\u003e 出现在作用域解析操作符 `::` 右边的名字是限定名（参阅有限定的标识符）。 限定名可能代表的是：\n\u003e\n\u003e - 类的成员（包括静态和非静态函数、类型和模板等）\n\u003e - 命名空间的成员（包括其他的命名空间）\n\u003e - 枚举项\n\n如果 `::` 左边为空，那么查找过程只会考虑全局命名空间作用域中作出（或通过 using 声明引入到全局命名空间中）的声明。\n\n```cpp\nthis-\u003ef();\n```\n\n那么显然，这个表达式 **不是有限定名字查找**，那么我们就去[无限定名字查找](https://zh.cppreference.com/w/cpp/language/unqualified_lookup)中寻找答案。\n\n我们找到**模板定义**：\n\n\u003e 对于在模板的定义中所使用的**非待决名**，当**检查该模板的定义时将进行无限定的名字查找**。在这个位置与声明之间的绑定并不会受到在实例化点可见的声明的影响。\n\u003e 而对于在模板定义中所使用的**待决名**，**它的查找会推迟到得知它的模板实参之时**。\n\u003e 此时，ADL 将同时在模板的定义语境和在模板的实例化语境中检查可见的具有外部连接的（C++11 前）函数声明，而非 ADL 的查找只会检查在模板的定义语境中可见的具有外部连接的（C++11 前）函数声明。\n\u003e（换句话说，在模板定义之后添加新的函数声明，除非通过 ADL 否则仍是不可见的。）\n\u003e 如果在 ADL 查找所检查的命名空间中，在某个别的翻译单元中声明了一个具有外部连接的更好的匹配声明，或者如果当同样检查这些翻译单元时其查找会导致歧义，那么行为未定义。\n\u003e 无论哪种情况，如果某个基类取决于某个模板形参，**那么无限定名字查找不会检查它的作用域（在定义点和实例化点都不会）**。\n\n原文很长，但是看我们加粗的也足够了。如果你没有学习过[待决名](https://zh.cppreference.com/w/cpp/language/dependent_name)，那这又会引入一个问题了。\n\n我们这里简单描述一下吧：\n\n`this-\u003ef()` 是一个待决名，这个 `this` 依赖于模板 `X`。\n\n所以，我们的问题可以解决了吗？\n\n1. `this-\u003ef()` **是待决名**，所以它的查找会推迟到得知它模板实参之时（届时可以确定父类是否有 `f` 函数）。\n2. `f()` **是非待决名**，检查该模板的定义时将进行无限定的名字查找（无法查找父类的定义），按照正常的查看顺序，先类内（查找不到），然后全局（找到）。\n\n\u003e补充：如果是 `msvc` 的某些早期版本，或者 c++版本设置在 C++20之前，会打印 `X` `X`。这是因为 `msvc`不支持 [`Two-phase name lookup`](https://learn.microsoft.com/zh-cn/archive/blogs/c/msvc%E5%B7%B2%E7%BB%8F%E6%94%AF%E6%8C%81two-phase-name-lookup)。\n详细的可以看看文档。实测 `Microsoft Visual Studio 17.6.4` 设置 `C++20` 之前的版本都无法得到正确结果。\n\n\u003c/details\u003e\n\n---\n\n## `10` 遍历任意类数据成员\n\n出题人：`mq白` 日期：`2023/8/18`\n\n题目的要求非常简单，在很多其他语言里也经常提供这种东西（一般是反射）。\n但是显而易见 `C++` 没有反射。\n\n我们给出代码：\n\n```cpp\nint main() {\n    struct X { std::string s{ \" \" }; }x;\n    struct Y { double a{}, b{}, c{}, d{}; }y;\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n';\n    std::cout \u003c\u003c size\u003cY\u003e() \u003c\u003c '\\n';\n\n    auto print = [](const auto\u0026 member) {\n        std::cout \u003c\u003c member \u003c\u003c ' ';\n    };\n    for_each_member(x, print);\n    for_each_member(y, print);\n}\n```\n\n要求自行实现 `for_each_member` 以及 `size` 模板函数。\n要求支持任意自定义类类型（**聚合体**）的数据成员遍历（**聚合体中存储数组这种情况不需要处理，具体原因看最后的[补充说明](#补充说明)**）。\n这需要打表，那么我们的要求是支持聚合体拥有 `0` 到 `4` 个数据成员的遍历。\n\u003e如果从来没有接触过，那这道题有相当的难度，可以等 **标准答案** 以及 **视频**。或者去网络上查找这方面的知识。\n\n### 运行结果\n\n```text\n1\n4\n  0 0 0 0\n```\n\n- 难度: **★★★★☆**\n\n\u003e 第二个四星题目\n\n提示：[学习](https://akrzemi1.wordpress.com/2020/10/01/reflection-for-aggregates/)\n\n\u003cdetails id=\"群友提交-9\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第10题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-9\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n分为 **`C++20`** 的写法和 **`C++17`** 的写法。\n`C++20` 得益于 [**`requires`**](https://zh.cppreference.com/w/cpp/language/requires) 表达式，可以简化不少地方。主要在于 **获取聚合类型的成员个数**，即 `size`函数的实现方式的不同。\n\n其他的，诸如用于在不求值语境的 `init` 辅助类，或者用于遍历的 `for_each_member` 函数，在 `C++17` 和 `C++20` 没什么区别。\n\n我们统一先放标准答案的代码再一一讲解。\n\n#### `C++17` 写法\n\n```cpp\n#include \u003ciostream\u003e\n#include\u003ctype_traits\u003e\n\nstruct init {\n    template \u003ctypename T\u003e\n    operator T(); // 无定义 我们需要一个可以转换为任何类型的在以下特殊语境中使用的辅助类\n};\n\ntemplate\u003cunsigned I\u003e\nstruct tag :tag\u003cI - 1\u003e {};//模板递归展开 继承 用来规定重载的匹配顺序 如果不这么写，匹配是无序的\ntemplate\u003c\u003e\nstruct tag\u003c0\u003e {};\n\ntemplate \u003ctypename T\u003e//SFIANE\nconstexpr auto size_(tag\u003c4\u003e) -\u003e decltype(T{ init{}, init{}, init{}, init{} }, 0u)\n{\n    return 4u;\n}\ntemplate \u003ctypename T\u003e\nconstexpr auto size_(tag\u003c3\u003e) -\u003e decltype(T{ init{}, init{}, init{} }, 0u)\n{\n    return 3u;\n}\ntemplate \u003ctypename T\u003e\nconstexpr auto size_(tag\u003c2\u003e) -\u003e decltype(T{ init{}, init{} }, 0u)\n{\n    return 2u;\n}\ntemplate \u003ctypename T\u003e\nconstexpr auto size_(tag\u003c1\u003e) -\u003e decltype(T{ init{} }, 0u)\n{\n    return 1u;\n}\ntemplate \u003ctypename T\u003e\nconstexpr auto size_(tag\u003c0\u003e) -\u003e decltype(T{}, 0u)\n{\n    return 0u;\n}\ntemplate \u003ctypename T\u003e\nconstexpr size_t size() {\n    static_assert(std::is_aggregate_v\u003cT\u003e);//检测是否为聚合类型\n    return size_\u003cT\u003e(tag\u003c4\u003e{});//这里就是要求从tag\u003c4\u003e开始匹配，一直到tag\u003c0\u003e\n}\n\ntemplate \u003ctypename T, typename F\u003e\nvoid for_each_member(T const\u0026 v, F\u0026\u0026 f) {\n    static_assert(std::is_aggregate_v\u003cT\u003e);//检测是否为聚合类型\n\n    if constexpr (size\u003cT\u003e() == 4u) {//使用C++17的编译期if和结构化绑定来遍历\n        const auto\u0026 [m0, m1, m2, m3] = v;\n        f(m0); f(m1); f(m2); f(m3);\n    }\n    else if constexpr (size\u003cT\u003e() == 3u) {\n        const auto\u0026 [m0, m1, m2] = v;\n        f(m0); f(m1); f(m2);\n    }\n    else if constexpr (size\u003cT\u003e() == 2u) {\n        const auto\u0026 [m0, m1] = v;\n        f(m0); f(m1);\n    }\n    else if constexpr (size\u003cT\u003e() == 1u) {\n        const auto\u0026 [m0] = v;\n        f(m0);\n    }\n}\n\nint main() {\n    struct X { std::string s{ \" \" }; }x;\n    struct Y { double a{}, b{}, c{}, d{}; }y;\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n';\n    std::cout \u003c\u003c size\u003cY\u003e() \u003c\u003c '\\n';\n\n    auto print = [](const auto\u0026 member) {\n        std::cout \u003c\u003c member \u003c\u003c ' ';\n    };\n    for_each_member(x, print);\n    for_each_member(y, print);\n}\n```\n\n[代码运行](https://godbolt.org/z/3GY5ah88G)\n\n我们稍微聊一下那个模板类 `tag` 的作用，它那里是一个模板递归继承，注释也写了，用来规定重载决议匹配顺序，那么原理是什么呢？\n\n```cpp\n#include \u003ciostream\u003e\n\nstruct X{};\nstruct Y:X{};\nstruct G:Y{};\n\nstruct X2:X{};\n\nvoid f(X) { puts(\"X\"); }\nvoid f(Y) { puts(\"Y\"); }\n\nvoid f2(X) { puts(\"X\"); }\n\nint main(){\n    f(G{});//G的父类是Y，重载决议优先选择f(Y)\n    f2(G{});//但是实际上使用X一样可以，当没有更匹配的重载，重载决议会选择到f2(X)\n}\n```\n\n[运行结果](https://godbolt.org/z/nGvjqo9bq)\n\n```text\nX\nY\n```\n\n我们继续看 `tag` 的代码\n\n```cpp\n\ntemplate\u003cunsigned I\u003e\nstruct tag : tag\u003cI - 1\u003e {};\ntemplate\u003c\u003e\nstruct tag\u003c0\u003e {};\n```\n\n假设我们实例化了 `tag\u003c4\u003e`，那么相当于\n\n```cpp\ntemplate\u003c4\u003e\nstruct tag :tag\u003c3\u003e {};\n```\n\n然后递归，以此类推，最终到 `tag\u003c0\u003e`，结束。\n\n也就是说 `tag\u003c4\u003e` 继承自 `tag\u003c3\u003e`，`tag\u003c2\u003e` 继承自 `tag\u003c1\u003e`，`tag\u003c1\u003e` 继承自 `tag\u003c0\u003e`。\n\n然后看到 `size_\u003cT\u003e(tag\u003c4\u003e{});` 以及 `size_` 模板的几个重载。\n\n结合我们之前说的，我们可以知道，这样就是约束匹配顺序从\n\n```cpp\ntemplate \u003ctypename T\u003e\nconstexpr auto size_(tag\u003c4\u003e) -\u003e decltype(T{ init{}, init{}, init{}, init{} }, 0u);\n```\n\n开始，一直到\n\n```cpp\ntemplate \u003ctypename T\u003e\nconstexpr auto size_(tag\u003c0\u003e) -\u003e decltype(T{}, 0u);\n```\n\n也就是从大到小，获取传入的聚合类型的成员个数。\n\n---\n\n#### `C++20` 写法\n\n```cpp\n#include \u003ciostream\u003e\n#include \u003ctype_traits\u003e\n\nstruct init {\n    template \u003ctypename T\u003e\n    operator T(); // 无定义 我们需要一个可以转换为任何类型的在以下特殊语境中使用的辅助类\n};\n\ntemplate \u003ctypename T\u003e\nconsteval size_t size(auto\u0026\u0026...Args) {\n    if constexpr (!requires{T{ Args... }; }) {\n        return sizeof...(Args) - 1;\n    }\n    else {\n        return size\u003cT\u003e(Args..., init{});\n    }\n}\n\ntemplate \u003ctypename T, typename F\u003e\nvoid for_each_member(T const\u0026 v, F\u0026\u0026 f) {//和C++17的写法一毛一样\n    static_assert(std::is_aggregate_v\u003cT\u003e);//检测是否为聚合类型\n\n    if constexpr (size\u003cT\u003e() == 4u) {//使用C++17的编译期if和结构化绑定来遍历\n        const auto\u0026 [m0, m1, m2, m3] = v;\n        f(m0); f(m1); f(m2); f(m3);\n    }\n    else if constexpr (size\u003cT\u003e() == 3u) {\n        const auto\u0026 [m0, m1, m2] = v;\n        f(m0); f(m1); f(m2);\n    }\n    else if constexpr (size\u003cT\u003e() == 2u) {\n        const auto\u0026 [m0, m1] = v;\n        f(m0); f(m1);\n    }\n    else if constexpr (size\u003cT\u003e() == 1u) {\n        const auto\u0026 [m0] = v;\n        f(m0);\n    }\n}\n\nint main() {\n    struct X { std::string s{ \" \" }; }x;\n    struct Y { double a{}, b{}, c{}, d{}; }y;\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n';\n    std::cout \u003c\u003c size\u003cY\u003e() \u003c\u003c '\\n';\n\n    auto print = [](const auto\u0026 member) {\n        std::cout \u003c\u003c member \u003c\u003c ' ';\n    };\n    for_each_member(x, print);\n    for_each_member(y, print);\n}\n```\n\n[代码运行](https://godbolt.org/z/dbTPGhvKd)\n\n我们来描述一下`size`模板函数的实现。\n\u003e他的设计非常的巧妙，如你所见，它是一个递归函数，还是编译期的递归，使用到了 **编译期 `if`** ；并且这个函数是以 [`consteval`](https://zh.cppreference.com/w/cpp/language/consteval) 修饰，是立即函数，即必须在编译期执行，**产生编译时常量**。\n\n好，我们正式进入这个函数。首先看到函数前两行，模板和 `C++20` 简写模板，这是一个形参包，万能引用。`typename T` 的 `T` 是指代外部传入的，需要获取成员个数的聚合体类型。\n\n```cpp\ntemplate \u003ctypename T\u003e\nconsteval size_t size(auto\u0026\u0026...Args)\n```\n\n然后是\n\n```cpp\nif constexpr (!requires{T{ Args... }; })\n```\n\n这句话表示的是：传入的聚合体类型如果可以 `T{ Args... }`这样构造，那就不进入分支。注意这个 **`!`**。\n\n我们先重复一下聚合体的匹配，假设有一个聚合类型 `X`，如下所示：\n\n```cpp\nstruct X{\n    int a,b,c;\n};\n```\n\n它支持几个参数的初始化呢？如下所示\n\n```cpp\nX x0{};        //ok\nX x1{1};       //ok\nX x2{1,2};     //ok\nX x3{1,2,3};   //ok\nX x4{1,2,3,4}; //error\n```\n\n**上面这段例子非常重要**。显然，只要传入的参数类型符合要求，并且**不超过其成员个数**即可。\n\n我们再给一段代码：\n\n```cpp\n#include \u003ciostream\u003e\n\nstruct init {\n    template \u003ctypename T\u003e\n    operator T(); // 无定义 我们需要一个可以转换为任何类型的在以下特殊语境中使用的辅助类\n};\n\ntemplate\u003ctypename T\u003e\nconsteval size_t size(auto\u0026\u0026...Args) {\n    if constexpr (!requires{T{ Args... }; }) {\n        return sizeof...(Args) - 1;\n    }\n    else {\n        return size\u003cT\u003e(Args..., init{});\n    }\n}\n\nstruct X{\n    int a,b,c;\n};\n\nint main(){\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n';//3\n}\n```\n\n我们一步一步带入解释，为什么会打印 **3**。\n\n1. 进入 `size` 函数，`T` 是 `X`类型，形参包 `Args` 为**空**。\n2. 编译期 `if` 中，条件表达式等价于 `! requires{ X{}; }` 。显然 `X{}` 符合语法，`requires` 表达式会返回 `true` 但是有 **`!`**，那就是  **`false`**。不进入这个分支。\n3. 进入 `else`，直接相当于 `return size\u003cX\u003e(init{})` 。\n4. **第二次** 进入 `size` 函数，此时形参包 `Args` 有**一个**参数 `init`。\n5. 编译期 `if` 中，条件表达式等价于 `! requires{ X{ init{} }; }`。显然 `X{ init{} }` 符合语法。同 `2` 返回 **`false`**，不进入分支。\n6. 进入 `else`，直接相当于 `return size\u003cX\u003e(init{},init{})`。\n7. **第三次** 进入 `size` 函数，此时形参包 `Args` 有**两个**参数 `init`。\n8. 编译期 `if` 中，条件表达式等价于 `! requires{ X{ init{},init{} } }`。显然同 `2` `5` 返回 **`false`**，不进入分支。\n9. 进入 `else`，直接相当于 `return size\u003cX\u003e(init{},init{},init{})`。\n10. **第四次** 进入 `size` 函数，此时形参包 `Args` 有**三个**参数 `init`。\n11. 编译期 `if` 中，条件表达式等价于 `! requires{ X{ init{},init{},init{} } }`，显然同 `2` `5` `8` 返回 **`false`**，不进入分支。\n12. 进入 `else`，直接相当于 `return size\u003cX\u003e(init{},init{},init{},init{})`。\n13. **第五次** 进入 `size` 函数，此时形参包 `Args` 有**四个**参数 `init`。（**注意，重点要来了，`X` 类型只有三个成员**）\n14. 编译期 `if` 中，条件表达式等价于 `! requires{ X{ init{},init{},init{},init{} } }`，即 `X{ init{},init{},init{},init{} }`不符合语法（`X` 类型只有三个成员）。\n所以 `requires` 表达式返回 `false`，然后因为 **`!`**，表达式结果为 **`true`**，进入分支。\n15. `return sizeof...(Args) - 1;` 注意，我们说了，第五次进入的时候，形参包 `Args` 已经有四个参数，所以`sizeof...(Args)`会返回 `4`，再 `-1`，也就是  **`3`**。**得到最终结果**。\n\n到此，我们介绍完了 `C++20`写法的 获取聚合类型的 `size` 函数。\n\n至于 `for_each_member` 没必要再介绍，很普通简单的分支逻辑而已，只不过是用了编译期的分支。\n\n### 无法处理引用类型以及不可移动类型\n\n先前的代码没办法处理引用类型和不可移动类型，如下：\n\n```cpp\nstruct init {\n    template \u003ctypename T\u003e\n    operator T(); \n};\n\ntemplate \u003ctypename T\u003e\nconsteval size_t size(auto\u0026\u0026...Args) {\n    if constexpr (!requires{T{ Args... }; }) {\n        return sizeof...(Args) - 1;\n    }\n    else {\n        return size\u003cT\u003e(Args..., init{});\n    }\n}\n\nstruct X{\n    int\u0026 v1,v2,v3; // 换成 int\u0026\u0026 也都同理\n};\n\nint main(){\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n'; // 18446744073709551615\n}\n```\n\n```cpp\nstruct init {\n    template \u003ctypename T\u003e\n    operator T(); \n};\n\ntemplate \u003ctypename T\u003e\nconsteval size_t size(auto\u0026\u0026...Args) {\n    if constexpr (!requires{T{ Args... }; }) {\n        return sizeof...(Args) - 1;\n    }\n    else {\n        return size\u003cT\u003e(Args..., init{});\n    }\n}\n\nstruct X{\n    std::mutex m;   // 不可移动不可复制\n    int v1,v2,v3;\n};\n\nint main(){\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n'; // 0\n}\n```\n\n换自己写的：\n\n```cpp\nstruct init {\n    template \u003ctypename T\u003e\n    operator T(); \n};\n\ntemplate \u003ctypename T\u003e\nconsteval size_t size(auto\u0026\u0026...Args) {\n    if constexpr (!requires{T{ Args... }; }) {\n        return sizeof...(Args) - 1;\n    }\n    else {\n        return size\u003cT\u003e(Args..., init{});\n    }\n}\n\nstruct Y\n{\n    Y() {}\n    Y(const Y\u0026) {}\n    Y(Y\u0026\u0026) = delete;\n};\n\nstruct X{\n    Y y1,y2,y3,y4;\n};\n\nint main(){\n    std::cout \u003c\u003c size\u003cX\u003e() \u003c\u003c '\\n';\n}\n```\n\n懒得改。\n\n\u003c/details\u003e\n\n\u003cdetails id=\"补充说明-0\"\u003e\n    \u003csummary\u003e补充说明\u003c/summary\u003e\n\n### 补充说明\n\n我们给出的 `C++20` 或 `C++17` 的 `size` 的实现是有问题的，简单的说，**它没办法处理聚合类型存储数组的问题**，包括引用、不可移动类型。在题目开头我们也说了。\n我们拿 [`boost::pfr`](https://www.boost.org/doc/libs/1_82_0/doc/html/boost_pfr/tutorial.html) 的行为作为参考，我们采用1.82.0版本。\n\n参见 [示例代码](src/群友提交/第10题/with_boost_pfr.md)\n\n\u003c/details\u003e\n\n---\n\n## `11` `emplace_back()` 的问题\n\n日期：**`2023/8/20`** 出题人：[**`jacky`**](https://github.com/rsp4jack)\n\n思考：以下代码为什么在 `C++20` 以下的版本中无法成功编译，而在 `C++20` 及以后却可以？\n\n```cpp\n#include \u003cvector\u003e\n\nstruct Pos {\n    int x;\n    int y;\n};\n\nint main(){\n    std::vector\u003cPos\u003e vec;\n    vec.emplace_back(1, 5);\n}\n```\n\n- 难度:**★★☆☆☆**\n\n\u003cdetails id=\"群友提交-10\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第11题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-10\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n你在使用 `gcc` 并且设置标准在 C++20 之前，会得到 [编译器的提示信息](https://godbolt.org/z/rdjjYEcje)\n\n```text\nerror: new initializer expression list treated as compound expression [-fpermissive]\n  187 |         { ::new((void *)__p) _Up(std::forward\u003c_Args\u003e(__args)...); }\n      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n```\n\n实际上 `std::vector\u003cT\u003e::emplace_back()` 最终会使用类似如下的代码构造对象：\n\n```cpp\n::new (static_cast\u003cvoid*\u003e(p)) T(std::forward\u003cArgs\u003e(args)...)//也就是完美转发+布置new\n```\n\n实际上是因为在 C++20 中增加了 “**括号形式的聚合初始化**”（用词并不准确，当字面意思凑合理解即可）。按照[文档](https://zh.cppreference.com/w/cpp/language/direct_initialization)的描述\n\n\u003e 如果目标类型是（可能有 cv 限定）的 **聚合类**，则 **按聚合初始化** 中所述进行初始化，但允许窄化转换，不允许指派初始化器，不延长引用所绑定到的临时量的生存期，不进行花括号消除，并值初始化任何无初始化器的元素。\n\n我们不需要关注那么多，我们用一段代码来演示：\n\n```cpp\nstruct Pos {\n    int x;\n    int y;\n};\n\nint main(){\n    Pos p(0,0);//C++20起允许\n}\n```\n\n所以说白了，就是 `T(std::forward\u003cArgs\u003e(args)...)` 这里用的小括号进行初始化，直到 C++20才允许聚合类型使用小括号初始化。\n\n\u003c/details\u003e\n\n---\n\n## `12` 实现`make_vector()`\n\n日期：**`2023/8/28`** 出题人：[**`jacky`**](https://github.com/rsp4jack)\n\n请实现函数 `make_vector(...)`，使以下代码编译通过（**C++20**）：\n\n```cpp\n#include \u003ccstdio\u003e\n#include \u003cvector\u003e\n\ninline void dbg(const char* msg)\n{\n    std::puts(msg);\n    std::fflush(stdout);\n}\n\nstruct X {\n    X() noexcept\n    {\n        dbg(\"X()\");\n    };\n\n    ~X() noexcept\n    {\n        dbg(\"~X()\");\n    };\n\n    X(const X\u0026)\n    {\n        dbg(\"X(const X\u0026)\");\n    }\n\n    X(X\u0026\u0026) noexcept\n    {\n        dbg(\"X(X\u0026\u0026)\");\n    }\n};\n\nvoid test()\n{\n    static_assert(requires {\n        {\n            make_vector(std::vector{1, 2, 3})\n        } -\u003e std::same_as\u003cstd::vector\u003cstd::vector\u003cint\u003e\u003e\u003e;\n        {\n            make_vector(1, 2, 3)\n        } -\u003e std::same_as\u003cstd::vector\u003cint\u003e\u003e;\n        make_vector(1, 2, 3).size() == 3;\n    });\n    X    x1;\n    X    x2;\n    auto vec = make_vector(x1, std::move(x2));\n}\n\nint main()\n{\n    test();\n    dbg(\"test end\");\n}\n```\n\n### [运行结果](https://godbolt.org/z/qYn74qGee)\n\n```text\nX()\nX()\nX(const X\u0026)\nX(X\u0026\u0026)\nX(const X\u0026)\nX(const X\u0026)\n~X()\n~X()\n~X()\n~X()\n~X()\n~X()\ntest end\n```\n\n- 难度:**★★★☆☆**\n\n\u003cdetails id=\"群友提交-11\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第12题)\n\n答题者：[`yuzhiy`](src/群友提交/第12题/yuzhiy.cpp)\n\n```cpp\ntemplate\u003ctypename...Args\u003e\nauto make_vector(Args\u0026\u0026...args)-\u003edecltype(auto){\n    return std::vector({std::forward\u003cArgs\u003e(args)...});\n}\n```\n\n\u003e 没啥问题，就是 `auto` 占位，后置返回类型 `decltype(auto)` 没意义。\n\n答题者：[`Matrix-A`](src/群友提交/第12题/Matrix-A.cpp)\n\n```cpp\nauto make_vector(auto\u0026\u0026... args) {\n    std::vector\u003cstd::common_type_t\u003cdecltype(args)...\u003e\u003e temp;\n    (temp.emplace_back(std::forward\u003cdecltype(args)\u003e(args)),...);\n    return temp;\n}\n```\n\n\u003e 用 `emplace_back()` 比直接往 `vector` 的初始化器里面传入参数要少拷贝。可[自行测试](https://gcc.godbolt.org/z/3bo7oKfEq)。\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-11\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\ntemplate\u003ctypename T,typename...Args\u003e\nconstexpr auto make_vector(T\u0026\u0026t,Args\u0026\u0026...args) {\n    return std::vector\u003cstd::remove_cvref_t\u003cT\u003e\u003e{ std::forward\u003cT\u003e(t), std::forward\u003cArgs\u003e(args)... };\n}\n```\n\n\u003e 这种写法纯属为了解决下面解法提到的问题（即推导问题）\n\n```cpp\ntemplate\u003ctypename...Args\u003e\nconstexpr auto make_vector(Args\u0026\u0026...args) {\n    return std::vector({ std::forward\u003cArgs\u003e(args)... });\n}\n```\n\n事实上大多数人看到这段代码会觉得很简单，就这么一行核心代码。实际上这里有很多坑，如果你没有自己写过不会注意到，即使你自己写过，大多人也并不明白。\n\n即：**为什么需要 `std::vector({})` 这种形式？如果我不这么做呢？只用 `()` 或者 `{}` 呢？有什么替代方式吗？**\n\n我们如果去掉外面的 `()` 进行编译，会发生一个**编译错误**，编译器提示我们是 `static_assert` 中一个 `requires` 表达式的条件无法被满足：\n\n```cpp\n{\n    make_vector(std::vector{1, 2, 3})\n} -\u003e std::same_as\u003cstd::vector\u003cstd::vector\u003cint\u003e\u003e\u003e;\n```\n\n那么问题很简单了，就是 `make_vector(std::vector{1, 2, 3})` 这段代码无法得到 `std::vector\u003cstd::vector\u003cint\u003e\u003e` 类型（前提是我们去掉了 `()` ）。\n\n那么这个问题的本质是什么？\n\n```cpp\n//C++20\nstd::vector v{std::vector{1,2,3}};  // std::vector\u003cint\u003e\n```\n\n就这么简单，这就是这个问题表面上的本质，`vector` 再这种情况下也会得不到我们想要的类型。\n\n我们接下来需要解释为什么 `vector` 会有这样的问题，并且，如果是：\n\n```cpp\nstd::vector v{std::vector{1},std::vector{2}}; //就能得到std::vector\u003cstd::vector\u003cint\u003e\u003e\n```\n\n我们写一个最小的复现 demo 即可\n\n```cpp\n#include \u003ccstdio\u003e\n#include \u003cvector\u003e\n\ntemplate\u003ctypename T\u003e\nstruct Test {\n    Test() {}\n    Test(std::initializer_list\u003cT\u003e) { puts(\"被调用\"); }\n    Test(const Test\u003cT\u003e\u0026) { puts(\"复制构造\"); }\n};\n\ntemplate\u003ctypename T\u003e\nTest(std::initializer_list\u003cT\u003e) -\u003e Test\u003cT\u003e;\n\nint main() {\n    Test\u003cint\u003e a;\n    Test t{ a,a }; //被调用         会推导为Test\u003cTest\u003cint\u003e\u003e\n    Test t2{ a };  //复制构造       会推导为Test\u003cint\u003e\n}\n```\n\n#### [运行结果](https://godbolt.org/z/jvKE7Mqhq)\n\n```text\n复制构造\n复制构造\n被调用\n复制构造\n```\n\n根据运行结果我们可以知道，`std::initializer_list` 的构造函数版本只被调用了一次，是 `Test t{ a,a };` 。\n\n`Test t2{ a };` 并没有调用 `std::initializer_list` 的构造函数。\n\n不用感到奇怪，这理所应当。\n\n**当从类型为正在构造的类模板的特化或特化子级的单个元素进行初始化时，复制构造函数优先于列表构造函数。**\n\n这就可以解释为什么直接 `{}` 不行，`({})` 的话就很明确了，只能调用 `initializer_list` 的构造函数。\n\n包括可以解释以下给出的**错误**写法：\n\n```cpp\ntemplate\u003ctypename... Args\u003e\nauto make_vector(const Args\u0026... elems){\n    return std::vector{elems...};\n}\nauto v2 = make_vector(std::vector{1,2,3});  // std::vector\u003cint\u003e\n```\n\n可参见[文档](https://oleksandrkvl.github.io/2021/04/02/cpp-20-overview.html#fix-init-list-ctad)描述。\n\n\u003c/details\u003e\n\n---\n\n## `13` 关于 `return std::move`\n\n日期：`2023/9/6` 出题人：`mq白`\n\n我们会给出三段使用到了 `return std::move` 代码。\n\n**解释说明这些代码是否有问题，问题在哪，或者没问题，那么为什么要这样使用。**\n\n1. 全局函数，返回局部对象，使用 `std::move`。\n\n    ```cpp\n    #include\u003ciostream\u003e\n\n    struct X{//后续代码不再重复X类\n        X() { puts(\"X()\"); }\n        X(const X\u0026) { puts(\"X(const X\u0026)\"); }\n        X(X\u0026\u0026)noexcept { puts(\"X(X\u0026\u0026)\"); }\n        ~X() { puts(\"~X()\"); }\n    };\n\n    X f(){\n        X x;\n        return std::move(x);\n    }\n\n    int main(){\n        X x = f();\n    }\n    ```\n\n2. 全局函数，返回局部的引用，使用 `std::move`。\n\n    ```cpp\n    X\u0026\u0026 f(){\n        X x;\n        return std::move(x);\n    }\n    ```\n\n3. 类中成员函数，返回数据成员，使用 `std::move`。\n\n    ```cpp\n    struct Test {\n        X x;\n        X f() {\n            return std::move(x);\n        }\n    };\n    ```\n\n- 难度:**★★★☆☆**\n\n\u003cdetails id=\"群友提交-12\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第13题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-12\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n看[博客](https://zhuanlan.zhihu.com/p/654113232)或[视频](https://www.bilibili.com/video/BV1SG41197RC/)都有讲。\n\n1. 函数局部的 `x` 对象是隐式可移动实体，可以调用移动构造，显式 `std::move` 毫无意义，甚至会影响 `NRVO` 优化。\n2. 返回局部的引用，这是悬垂的。\n3. 类的数据成员不是隐式可移动实体,如果不 `std::move`，而是直接 `return x`，重载决议不会选择移动构造。所以有意义。\n\n\u003c/details\u003e\n\n## `14` 以特殊方法修改命名空间中声明的对象\n\n日期：`2023/12/5` 出题人：`mq白`\n\n给出以下代码，不得修改，要求不得以\n\n- ss::a\n\n- using namespace ss\n\n- namespace x = ss，x::a\n  \n- using ss::a\n\n- 直接在 ss 命名空间中通过声明引用或指针指向 a，然后再去修改 a\n\n这些方式去修改命名空间 `ss` 中的对象 **a**，并且满足运行结果。\n\n需要真的修改了 a，而不是别的东西，诸如更改入口函数等。\n\n**不要求你的做法完全符合标准**。\n\n```cpp\n#include\u003ciostream\u003e\n\nnamespace ss {\n    int a = 0;\n}\n\nint main() {\n    // todo..\n    std::cout \u003c\u003c ss::a \u003c\u003c '\\n'; \n}\n```\n\n### 运行结果\n\n```txt\n100\n```\n\n- 难度: **★★★★☆**\n\n\u003e 本题其实是“**魔法**”题，并不是常规的那些，你可能会对本题的存在一些质疑，认为这种东西毫无价值，但这恰恰考察的是别的基础知识，如**符号修饰、链接、内存布局**。\n\u003e 越是写的奇特，诡异，**往往令人印象深刻**，这也正是教学的方式。\n\u003e 举个例子，别人和你说“C/C++ 的 #include 的本质是复制”，你可能没什么感觉，但是如果直接写一段代码呢？\n\n```cpp\nint arr[] = {\n#include\"1.txt\"\n};\n```\n\n\u003e **即使这种形式基本上没有任何的实际用途和价值，但是它能教会各位，让各位印象深刻，那也足够了。**\n\n\u003cdetails id=\"群友提交-13\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第14题)\n\n答题者：[**`Matrix-A`**](src/群友提交/第14题/Matrix-A.cpp)\n\n```cpp\n#include\u003ciostream\u003e\n#include\u003ccstdint\u003e\n\nnamespace ss {\n    int a = 0;\n}\n\n#if defined(_MSC_VER)\n#define MAIN_ATTRIBUTES __pragma(optimize(\"\", off))\n#elif defined(__clang__)\n#define MAIN_ATTRIBUTES [[clang::optnone]]\n#else\n#define MAIN_ATTRIBUTES [[gnu::optimize(0)]]\n#endif\n\nint b = 0;\nMAIN_ATTRIBUTES\nint main() {\n    *(int*)((uint8_t*)\u0026b - sizeof(int)) = 100;\n    *(int*)((uint8_t*)\u0026b + sizeof(int)) = 100;\n    std::cout \u003c\u003c ss::a \u003c\u003c '\\n';\n}\n```\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-13\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n#### 利用符号来解决\n\n```cpp\n#include\u003ciostream\u003e\n\nextern \"C\"{\n    namespace ss {\n        int a = 0;\n    }\n}\n\nextern \"C\" int a;\n\nint main() {\n    a = 100;\n    std::cout \u003c\u003c ss::a \u003c\u003c '\\n'; \n}\n```\n\n\u003e 利用 `extern \"C\"`，去除额外符号修饰解决，[实测](https://godbolt.org/z/os3WM4b9W)三平台通用（但显然不是标准规定的）。\n\n`extern \"C\"{ }` 包含了命名空间 `ss`，让对象 `a` 没有了额外的符号修饰，就是单纯的 `a`，如果不使用 `extern \"C\"` 包含，`ss::a` 的符号得是 **`_ZN2ss1aE`**。\n\n全局作用域的 `extern \"C\" int a;` 使用 `extern \"C\"` 能让对象 `a` 没有额外的符号修饰。也就是操作这个 `a` 等价于 `ss::a`，因为他们**编译后的符号是一样的**。\n\n也可以使用一些不太高明的方式，不需要用到 `extern \"C\"`\n\n```cpp\n#include\u003ciostream\u003e\n\nint a = 0;\n\nnamespace ss{\n    int a = 0;\n}\n\nextern int _ZN2ss1aE;\n\nint main(){\n    _ZN2ss1aE = 100;\n    std::cout\u003c\u003css::a\u003c\u003c'\\n';\n} \n```\n\n不过这种方式是写死的，并且这只支持 `gcc` 以及 `clang`，更多的解释看之前的[博客](https://zhuanlan.zhihu.com/p/667571439)。\n\n\u003cbr\u003e\n\n当然了，我们也可以利用预处理指令 [`#pragma comment`](https://learn.microsoft.com/zh-cn/cpp/preprocessor/comment-c-cpp?view=msvc-170)，来特殊处理 MSVC。**原理**：\n\n- [Itanium ABI](https://itanium-cxx-abi.github.io/cxx-abi/abi.html) 上变量 `ss::a` 的重整名为 `_ZN2ss1aE`。\n- 在 MSVC 可以使用 `#pragma comment` 添加 `/alternatename` 链接选项，指定在找不到符号 `?_ZN2ss1aE@@3HA` 时，使用符号 `?a@ss@@3HA` 作为替代。\n\n\u003e`?a@ss@@3HA` 就是 `ss::a` 的符号，而 `?_ZN2ss1aE@@3HA` 就是 `extern int _ZN2ss1aE` 的符号。\n\u003e\n\u003e因为 `_ZN2ss1aE` 没有定义，所以必然没有符号 `?_ZN2ss1aE@@3HA` ，就使用 `?a@ss@@3HA` 作为替代，那么此时操作 `_ZN2ss1aE` 如同操作 `ss::a`。\n\n```cpp\n#include\u003ciostream\u003e\n\nnamespace ss {\n    int a = 0;\n}\n\nint main() {\n    extern int _ZN2ss1aE;\n#ifdef _MSC_VER\n#pragma comment(linker, \"/alternatename:?_ZN2ss1aE@@3HA=?a@ss@@3HA\")\n#endif\n    _ZN2ss1aE = 100;\n    std::cout \u003c\u003c ss::a \u003c\u003c '\\n';\n}\n```\n\n\u003e\n\u003e 来源：[聚聚](https://github.com/Mq-b/Loser-HomeWork/pull/194)。\n\n#### 直接修改内存\n\n```cpp\n#include\u003ciostream\u003e\n#include\u003ccstdint\u003e\n\nnamespace ss {\n    int a = 0;\n}\n\nint b = 0;\n\nint main() {\n    *(int*)((uint8_t*)\u0026b - sizeof(int)) = 100;\n    *(int*)((uint8_t*)\u0026b + sizeof(int)) = 100;\n    std::cout \u003c\u003c ss::a \u003c\u003c '\\n';\n}\n```\n\n没啥说的，直接 UB 越界修改内存就完事了，在全局声明一个 `b` 只是用来做基地址进行偏移罢了。\n\n存在两个修改的原因是因为 ss::a 和 b 的前后顺序是不确定的，至少 msvc 和（clang、gcc）是不一样的，可能和系统有关。\n\n#### 利用名字查找规则\n\n```cpp\n#include\u003ciostream\u003e\n\nnamespace ss {\n    int a = 0;\n}\n\nnamespace ss {\n    extern int b;\n}\n\nint ss::b = a = 100;\n\nint main() {\n    std::cout \u003c\u003c ss::a \u003c\u003c'\\n';\n}\n```\n\n\u003e 来源：[mq 败](https://github.com/autobotoptimusprime)。\n\n当某个命名空间的成员变量在该命名空间外被定义时，该定义中用到的名字的查找会以与在命名空间之内使用的名字相同的方式进行。\n\n参见[文档](https://zh.cppreference.com/w/cpp/language/unqualified_lookup#.E5.9C.A8.E5.91.BD.E5.90.8D.E7.A9.BA.E9.97.B4.E5.A4.96.E8.BF.9B.E8.A1.8C.E5.AE.9A.E4.B9.89)。\n\n\u003c/details\u003e\n\n---\n\n## `15` 表达式模板\n\n日期：`2024/1/7` 出题人：[`Matrix-A`](https://github.com/Matrix-A)（[#159](https://github.com/Mq-b/Loser-HomeWork/issues/159)）\n\n1. 使用**表达式模板**补全下面的代码，实现表达式计算；\n2. 指出**表达式模板**和 STL Ranges 库中哪些**视图**类似，并指出它们的异同和优缺点。\n\n```cpp\n#include \u003calgorithm\u003e\n#include \u003cfunctional\u003e\n#include \u003ciostream\u003e\n#include \u003cranges\u003e\n#include \u003cvector\u003e\n\n// 为std::vector增加一个自定义的赋值函数\ntemplate \u003ctypename T\u003e\n    requires std::disjunction_v\u003cstd::is_integral\u003cT\u003e, std::is_floating_point\u003cT\u003e\u003e\nclass vector : public std::vector\u003cT\u003e {\npublic:\n    using std::vector\u003cT\u003e::vector;\n    using std::vector\u003cT\u003e::size;\n    using std::vector\u003cT\u003e::operator[];\n    template \u003ctypename E\u003e\n    vector\u003cT\u003e\u0026 operator=(const E\u0026 e)\n    {\n        const auto count = std::min(size(), e.size());\n        this-\u003eresize(count);\n        for (std::size_t idx { 0 }; idx \u003c count; ++idx) {\n            this-\u003eoperator[](idx) = e[idx];\n        }\n        return *this;\n    }\n};\n\n/*\n// 实现表达式模板类及相关函数\ntemplate\u003c...\u003e\nstruct vector_expr {\n\n};\n\n// operator+\n// operator-\n// operator*\n// operator/\n*/\n\nint main()\n{\n    auto print = [](const auto\u0026 v) {\n        std::ranges::copy(v, std::ostream_iterator\u003cstd::ranges::range_value_t\u003cdecltype(v)\u003e\u003e { std::cout, \", \" });\n        std::cout \u003c\u003c std::endl;\n    };\n    const vector\u003cdouble\u003e a { 1.2764, 1.3536, 1.2806, 1.9124, 1.8871, 1.7455 };\n    const vector\u003cdouble\u003e b { 2.1258, 2.9679, 2.7635, 2.3796, 2.4820, 2.4195 };\n    const vector\u003cdouble\u003e c { 3.9064, 3.7327, 3.4760, 3.5705, 3.8394, 3.8993 };\n    const vector\u003cdouble\u003e d { 4.7337, 4.5371, 4.5517, 4.2110, 4.6760, 4.3139 };\n    const vector\u003cdouble\u003e e { 5.2126, 5.1452, 5.8678, 5.1879, 5.8816, 5.6282 };\n\n    {\n        vector\u003cdouble\u003e result(6);\n        for (std::size_t idx = 0; idx \u003c 6; idx++) {\n            result[idx] = a[idx] - b[idx] * c[idx] / d[idx] + e[idx];\n        }\n        print(result);\n    }\n    {\n        vector\u003cdouble\u003e result(6);\n        result = a - b * c / d + e; // 使用表达式模板计算\n        print(result);\n    }\n    return 0;\n}\n```\n\n### 运行结果\n\n```txt\n4.73472, 4.05709, 5.038, 5.08264, 5.73076, 5.18673,\n4.73472, 4.05709, 5.038, 5.08264, 5.73076, 5.18673,\n```\n\n- 难度: **★★★☆☆**\n\n学习链接：\n\n- [Wikipedia - Expression templates](https://en.wikipedia.org/wiki/Expression_templates)\n- [我们不需要臭名昭著的表达式模板（英文）](https://gieseanw.wordpress.com/2019/10/20/we-dont-need-no-stinking-expression-templates/)\n- [C++语言的表达式模板：表达式模板的入门性介绍](https://blog.csdn.net/magisu/article/details/12964911)\n- [std::valarray](https://zh.cppreference.com/w/cpp/numeric/valarray) 在一些 STL 实现中使用了表达式模板\n\n\u003cdetails id=\"群友提交-14\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第15题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-14\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n```cpp\ntemplate\u003ctypename F, typename L, typename R\u003e\nstruct vector_expr {\n    const F\u0026 func;\n    const L\u0026 lhs;\n    const R\u0026 rhs;\n\n    std::size_t size() const {\n        return std::min(lhs.size(), rhs.size());\n    }\n    inline auto operator[](const size_t idx) const {\n        return func(lhs[idx], rhs[idx]);\n    }\n};\n\nauto operator+(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return vector_expr{ std::plus{}, lhs, rhs };\n}\nauto operator-(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return vector_expr{ std::minus{}, lhs, rhs };\n}\nauto operator*(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return vector_expr{ std::multiplies{}, lhs, rhs };\n}\nauto operator/(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return vector_expr{ std::divides{}, lhs, rhs };\n}\n```\n\n**表达式模板**是简化版的 `std::ranges::zip_transform_view`。\n\n优点：灵活，易用，可以充分利用编译器优化\n\n缺点：实现复杂\n\n\u003c/details\u003e\n\n\u003cdetails id=\"解析-3\"\u003e\n    \u003csummary\u003e解析\u003c/summary\u003e\n\n### 解析\n\n顾名思义，**表达式模板**指使用模板类表示表达式。表达式由**运算符**和**操作数**按照一定规律组合而成。\n\n观察题目中的表达式为 `a - b * c / d + e` 可知：\n\n1. 运算符：可以使用标准库中的通透的[**运算符函数对象**](https://zh.cppreference.com/w/cpp/utility/functional#.E9.80.9A.E9.80.8F.E5.87.BD.E6.95.B0.E5.AF.B9.E8.B1.A1)进行记录;\n2. 操作数：均为二元运算符，需要记录**左操作数**和**右操作数**;\n\n以 `a - b * c / d + e` 中的子表达式 `/` 为例，其运算符可以使用 `std::divides` ，左操作数为**表达式模板类对象** `b * c` ，右操作数为 `d` 。\n\n根据以上内容，通过在**重载运算符**生成**表达式模板类对象**，并在**表达式模板类**的 `operator[]` 中将**运算符函数对象**应用到**操作数**就可以简单的完成题目。\n\n在以上代码中，使用**表达式模板**通过**惰性求值**将**运算符函数对象**应用到**操作数**，这就是范围库中 [`std::ranges::zip_transform_view`](https://zh.cppreference.com/w/cpp/ranges/zip_transform_view)(C++23)。\n\n将上述代码替换为以下内容，也可以正确执行：\n\n```cpp\nauto operator+(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return std::ranges::zip_transform_view{ std::plus{}, lhs, rhs };\n}\nauto operator-(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return std::ranges::zip_transform_view{ std::minus{}, lhs, rhs };\n}\nauto operator*(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return std::ranges::zip_transform_view{ std::multiplies{}, lhs, rhs };\n}\nauto operator/(const auto\u0026 lhs, const auto\u0026 rhs) {\n    return std::ranges::zip_transform_view{ std::divides{}, lhs, rhs };\n}\n```\n\n综上所述，本题的**表达式模板**就是简化版的 `std::ranges::zip_transform_view`。\n\n我们只需要为**表达式模板**增加**亿**点点细节，就可以自行实现范围库了！🥳🥳🥳\n\n\u003c/details\u003e\n\n---\n\n## `16` 制造传递函数模板的宏\n\n日期：**`2024/2/6`** 出题人：**`mq白`**\n\n函数模板不是函数，所以如果要传递，必须实例化，指明模板参数，比如以下代码无法通过编译：\n\n```cpp\ntemplate\u003c class T \u003e\nconst T\u0026 min(const T\u0026 a, const T\u0026 b) {\n    return a \u003c b ? a : b;\n}\n\ntemplate\u003ctypename F,class...Args\u003e\nauto foo(F f,Args\u0026\u0026...args) {\n    return f(std::forward\u003cArgs\u003e(args)...);\n}\n\nint main() {\n    const auto result = foo(::min, 2, 3);\n    std::cout \u003c\u003c result \u003c\u003c '\\n';\n}\n```\n\n除非我们把里面的 `::min` 换成 `::min\u003cint\u003e`。这显然很麻烦，而且很多时候依然会有问题，比如这个函数模板有多个类型模板参数，又或者它有多个重载：\n\n```cpp\ntemplate\u003c class T \u003e\nconst T\u0026 min(const T\u0026 a, const T\u0026 b) {\n    return a \u003c b ? a : b;\n}\ntemplate\u003c class T \u003e\nT min(std::initializer_list\u003cT\u003e ilist) {\n    return std::min(ilist, std::less\u003c\u003e{});\n}\n\ntemplate\u003ctypename F, class...Args\u003e\nauto foo(F f, Args\u0026\u0026...args) {\n    return f(std::forward\u003cArgs\u003e(args)...);\n}\n\nint main() {\n    const auto result = foo(::min\u003cint\u003e, 2, 3);\n    std::cout \u003c\u003c result \u003c\u003c '\\n';\n}\n```\n\n重载决议根本没有任何办法处理。因此，[通透函数对象（Transparent function objects）](https://en.cppreference.com/w/cpp/utility/functional#Transparent_function_objects)应运而生。\n\n我们要解决以上问题，实现 ***`BY_NAME`*** 宏，从函数模板名创造通透函数对象，使以下代码能够成功编译：\n\n```cpp\ntemplate\u003ctypename F, class...Args\u003e\nauto foo(F f, Args\u0026\u0026...args) {\n    return f(std::forward\u003cArgs\u003e(args)...);\n}\n\nint main() {\n    const auto result = foo(BY_NAME(std::min), 2, 3);\n    std::cout \u003c\u003c result \u003c\u003c '\\n';\n}\n```\n\n- 难度：**★★☆☆☆**\n\n\u003cdetails id=\"群友提交-15\"\u003e\n    \u003csummary\u003e群友提交\u003c/summary\u003e\n\n### [群友提交](src/群友提交/第16题)\n\n\u003c/details\u003e\n\n\u003cdetails id=\"标准答案-15\"\u003e\n    \u003csummary\u003e标准答案\u003c/summary\u003e\n\n### 标准答案\n\n\u003c/details\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmq-b%2Floser-homework","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmq-b%2Floser-homework","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmq-b%2Floser-homework/lists"}