c++17

问题 This is a follow up to this question Consider the following code #include <variant> int add_(int a, int b){ return a+b; } float add_(float a, float b){ return a+b; } float add_(int a, float b){ return a+b; } float add_(float a, int b){ return a+b; } using Number = std::variant<int, float>; Number add(Number const& lhs, Number const& rhs ){ return std::visit( []( auto& lhs_, auto& rhs_ )->Number { return {add_( lhs_, rhs_ )}; }, lhs, rhs ); } int main(){ Number a = 1.f; Number b = 2.f; Number

问题 I would like to ask a question about structural binding and how the variables get their types. Here is the code I compile. struct T { explicit T(int a = 1) { a_ = a; std::cout << "Default" << std::endl; } T(const T& t) { a_ = t.a_; std::cout << "Copy" << std::endl; } int a_; }; int main() { std::tuple<bool, T> bi{true, T(1)}; std::cout << "START" << std::endl; auto& [b, i] = bi; static_assert(std::is_same<decltype(i), T>::value); std::cout << i.a_ << std::endl; i.a_++; std::cout << i.a_ <<

问题 Can I base a mission-critical application on the results of this test, that 100 threads reading a pointer set a billion times by a main thread never see a tear? Any other potential problems doing this besides tearing? Here's a stand-alone demo that compiles with g++ -g tear.cxx -o tear -pthread . #include <atomic> #include <thread> #include <vector> using namespace std; void* pvTearTest; atomic<int> iTears( 0 ); void TearTest( void ) { while (1) { void* pv = (void*) pvTearTest; intptr_t i =

问题 Can I base a mission-critical application on the results of this test, that 100 threads reading a pointer set a billion times by a main thread never see a tear? Any other potential problems doing this besides tearing? Here's a stand-alone demo that compiles with g++ -g tear.cxx -o tear -pthread . #include <atomic> #include <thread> #include <vector> using namespace std; void* pvTearTest; atomic<int> iTears( 0 ); void TearTest( void ) { while (1) { void* pv = (void*) pvTearTest; intptr_t i =

问题 I have a class MyType that implements a user-defined arithmetic type. This class provides the following conversion operator struct MyType { ... operator double() { return to_double(); // This converts my type to a double value } ... }; Using this class as follows works fine: double d = MyType(1); However, using this class as type within std::complex, e.g. #include <complex> std::complex<double> c = std::complex<MyType>(1,1); fails with the following compiler error: error: conversion from 'std

问题 Consider the following simple code: struct Base { Base() = default; Base(const Base&); Base(Base&&); }; struct Derived : Base { }; Base foo() { Derived derived; return derived; } clang 8.0.0 gives a warning -Wreturn-std-move on it: prog.cc:21:10: warning: local variable 'derived' will be copied despite being returned by name [-Wreturn-std-move] return derived; ^~~~~~~ prog.cc:21:10: note: call 'std::move' explicitly to avoid copying return derived; ^~~~~~~ std::move(derived) But if one called

问题 While playing around with std::variant and std::visit the following question came up: Consider the following code: using Variant = std::variant<int, float, double>; auto lambda = [](auto&& variant) { std::visit( [](auto&& arg) { using T = std::decay_t<decltype(arg)>; if constexpr (std::is_same_v<T, int>) { std::cout << "int\n"; } else if (std::is_same_v<T, float>) { std::cout << "float\n"; } else { std::cout << "double\n"; } }, variant); }; It works fine as the following examples show: lambda

问题 While looking at std::allocator, I see that members: value_type , pointer , const_pointer , reference , const_reference , size_type , difference_type , and rebind have all been deprecated. Allocators will also no longer have the members: address , max_size , construct , or destroy . Why did this happen? Did it have something to do with polymophic allocators? 回答1: If you look at the relevant isocpp paper you can see that the first set you mention is now thought to be better placed in std:

问题 I wonder what is the difference between this code that works : #include <type_traits> #include <iostream> template<typename T> using is_ref = std::enable_if_t<std::is_reference_v<T>, bool>; template<typename T> using is_not_ref = std::enable_if_t<!std::is_reference_v<T>, bool>; template<typename T, is_ref<T> = true> void foo(T&&) { std::cout << "ref" << std::endl; } template<typename T, is_not_ref<T> = true> void foo(T&&) { std::cout << "not ref" << std::endl; } int main() { int a = 0; foo(a)

问题 I have the following sample code template<class T1, class T2> class Operation { public: constexpr Operation(const T1& lhs, const T2& rhs) noexcept : m_lhs(lhs), m_rhs(rhs) { } private: const T1& m_lhs; const T2& m_rhs; }; int main() { constexpr int a = 3; constexpr int b = 4; constexpr Operation op(a, b); return 0; } Compiling this with cygwin (gcc 8.2) I get error: 'Operation<int, int>{a, b}' is not a constant expression: constexpr Operation op(a, b); With MSVC 2019 it compiles fine, but