language-lawyer

问题 I have a situation where I would like for two cases in a C++ switch statement to both fall through to a third case. Specifically, the second case would fall through to the third case, and the first case would also fall through to the third case without passing through the second case. I had a dumb idea, tried it, and it worked! I wrapped the second case in an if (0) { ... } . It looks like this: #ifdef __cplusplus # include <cstdio> #else # include <stdio.h> #endif int main(void) { for (int i

问题 In c++17 template <auto> allows to declare templates with arbitrary type parameters. Partially inspired by this question, it would be useful to have an extension of template <auto> that captures both type and nontype template parameters, and also allows for a variadic version of it. Are there plans for such an extension in the next c++20 release? Is there some fundamental problem in having a syntax like template<auto... X> , with X any type or nontype template parameter? 回答1: Are there plans

问题 In c++17 template <auto> allows to declare templates with arbitrary type parameters. Partially inspired by this question, it would be useful to have an extension of template <auto> that captures both type and nontype template parameters, and also allows for a variadic version of it. Are there plans for such an extension in the next c++20 release? Is there some fundamental problem in having a syntax like template<auto... X> , with X any type or nontype template parameter? 回答1: Are there plans

问题 In c++17 template <auto> allows to declare templates with arbitrary type parameters. Partially inspired by this question, it would be useful to have an extension of template <auto> that captures both type and nontype template parameters, and also allows for a variadic version of it. Are there plans for such an extension in the next c++20 release? Is there some fundamental problem in having a syntax like template<auto... X> , with X any type or nontype template parameter? 回答1: Are there plans

问题 Consider some function template such as: template <class T> const auto& foo() { static T t; return t; } The definition would not be valid if T were to be void . Nonetheless, we are allowed to instantiate the declaration alone without triggering an error: extern template const auto& foo<void>(); // explicit instantiation declaration Now let's consider situations where foo is called, rather than being explicitly instantiated. Obviously, if foo is ever called in an evaluated context, the

问题 This program: constexpr void f() { x: ; } is compiled by gcc, but clang says: error: statement not allowed in constexpr function So is this code valid? 回答1: As pointed out in a comment, clang is correct, and the code is ill-formed. According to the current working draft (which includes C++20), dcl.constexpr#3 says: The definition of a constexpr function shall satisfy the following requirements: ... its function-body shall not enclose ... an identifier label, ... ... 来源： https://stackoverflow

问题 Is the following C++ code standard compliant? #include <iostream> int main() { [](auto v){ std::cout << v << std::endl; }.operator()<int>(42); } Both clang++ 3.8.0 and g++ 7.2.0 compile this code fine (the compiler flags are -std=c++14 -Wall -Wextra -Werror -pedantic-errors ). 回答1: This is indeed standard compliant. The standard specifies there must be a member operator() , and that it has one template argument for every occurence of auto in its paramater-declaration-clause. There is no

问题 [dcl.spec.auto]/14 states [ emphasis mine]: An explicit instantiation declaration does not cause the instantiation of an entity declared using a placeholder type , but it also does not prevent that entity from being instantiated as needed to determine its type. [  Example: template <typename T> auto f(T t) { return t; } extern template auto f(int); // does not instantiate f<int> int (*p)(int) = f; // instantiates f<int> to determine its return type, but an explicit // instantiation definition

问题 [dcl.spec.auto]/14 states [ emphasis mine]: An explicit instantiation declaration does not cause the instantiation of an entity declared using a placeholder type , but it also does not prevent that entity from being instantiated as needed to determine its type. [  Example: template <typename T> auto f(T t) { return t; } extern template auto f(int); // does not instantiate f<int> int (*p)(int) = f; // instantiates f<int> to determine its return type, but an explicit // instantiation definition

问题 [dcl.spec.auto]/14 states [ emphasis mine]: An explicit instantiation declaration does not cause the instantiation of an entity declared using a placeholder type , but it also does not prevent that entity from being instantiated as needed to determine its type. [  Example: template <typename T> auto f(T t) { return t; } extern template auto f(int); // does not instantiate f<int> int (*p)(int) = f; // instantiates f<int> to determine its return type, but an explicit // instantiation definition