c++17

问题 In this question it's stated that it's impossible to just directly use template arguments for class constructor, because if you write something like struct S{ template<typename T> S() { ... } } Then you have no way of calling this constructor. However, there're some workarounds to make this work, for example, through template argument deduction. But all of these workarounds I know are for type arguments only. So, the question is Are there any workarounds to make this work for non-type

问题 So in c++11 the Chrono Library provides, duration_cast: Computations are done in the widest type available and converted, as if by static_cast, to the result type only when finished And c++17's floor: Returns the greatest duration t representable in ToDuration that is less or equal to d So for all x will the result of these 2 calls be equal: chrono::duration_cast<chrono::seconds>(x) chrono::floor<chrono::seconds>(x) 回答1: As far as I can tell, same as the difference between static_cast and std

问题 Consider following code: struct A {}; template <typename T> struct B { B(T) {} auto foo() {return B(A{});} // error: no matching function for call to 'B<int>::B(A)' }; auto foo() {return B(A{});} // compiles int main() { foo(); B b(0); b.foo(); } Try it live I understand why B::foo() doesn't compile: Inside of struct B<T> , B (as an injected-class-name) means B<T> unless it's explicitly used as a template. Which in this case prevents class template argument deduction. Let's say I can't do

问题 I want to traverse a map using structure bindings, ignoring the key: for (auto& [unused, val] : my_map) do_something(val); I have tried different options with gcc-7.2.0: // The warning is issued for ([[maybe_unused]] auto& [unused, val] : my_map) do_something(val); // Syntax error for (auto& [[[maybe_unused]] unused, val] : my_map) do_something(val); // The same two combinations above with [[gnu::unused]]. It seems that the [[maybe_unused]] attribute is not implemented yet for structure

问题 I want to traverse a map using structure bindings, ignoring the key: for (auto& [unused, val] : my_map) do_something(val); I have tried different options with gcc-7.2.0: // The warning is issued for ([[maybe_unused]] auto& [unused, val] : my_map) do_something(val); // Syntax error for (auto& [[[maybe_unused]] unused, val] : my_map) do_something(val); // The same two combinations above with [[gnu::unused]]. It seems that the [[maybe_unused]] attribute is not implemented yet for structure

问题 Is it possible to determine how many variable names should I to specify in square brackets using structured bindings syntax to match the number of data members of a plain right hand side struct ? I want to make a part of generic library, which uses structured bindings to decompose arbitrary classes into its constituents. At the moment there is no variadic version of structured bindings (and, I think, cannot be for current syntax proposed), but my first thought is to make a set of overloadings

问题 Consider these two approaches that can represent an "optional int ": using std_optional_int = std::optional<int>; using my_optional_int = std::pair<int, bool>; Given these two functions... auto get_std_optional_int() -> std_optional_int { return {42}; } auto get_my_optional() -> my_optional_int { return {42, true}; } ...both g++ trunk and clang++ trunk (with -std=c++17 -Ofast -fno-exceptions -fno-rtti ) produce the following assembly: get_std_optional_int(): mov rax, rdi mov DWORD PTR [rdi],

问题 I have a std::variant that I'd like to convert to another std::variant that has a super-set of its types. Is there a way of doing it than that allows me to simply assign one to the other? template <typename ToVariant, typename FromVariant> ToVariant ConvertVariant(const FromVariant& from) { ToVariant to = std::visit([](auto&& arg) -> ToVariant {return arg ; }, from); return to; } int main() { std::variant<int , double> a; a = 5; std::variant <std::string, double, int> b; b = ConvertVariant

问题 I try next code with three compilers (msvc2017, gcc8.2, clang7.0) and msvc2017 works all the way, but gcc and clang not. I want to understand what is wrong with my code, and why compiler can't compile it. #include <cassert> #include <iostream> #include <cstdlib> class Downloader { public: struct Hints { int32_t numOfMaxEasyHandles = 8; //Hints(){} // <= if I uncomment this all works gcc+clang+msvc //Hints() = default; // <= if I uncomment this neither clang no gcc works (msvc - works) };

问题 This question already has answers here : multiple definition of template specialization when using different objects (4 answers) Explicit specialization of function templates causes linker error (2 answers) Closed 6 months ago . I had previously asked this question that involved using auto with variadic templates that generates a tuple and the proper way to iterate over them. User metalfox had provided me with this solution. I tried their solution and this is what my full code looks like