小编kaw*_*ken的帖子

如何使用概念if constexpr？

给出下面的例子,if constexpr如果T满足要求,则返回1 将给予integral什么？

template<typename T>
concept integral = std::is_integral_v<T>;

struct X{};

template<typename T>
constexpr auto a () {
    if constexpr (/* T is integral */) {
        return 1;
    } 
    else {
        return 0;
    }
}

int main () {
    return a<X>();
}

我试图在内部lambda中捕获一个可变参数的lambda参数，并在其中使用它。例如，考虑以下代码：

int main () {
    auto first = [&] (auto&&... one) {
        auto second = [&] (auto&&... two) {
            return ((one * two) + ...);
        };
        return second(one...);
    };
    return first(5);
}

这适用于gcc9，但不适用于clang8（https://godbolt.org/z/i2K9cK）。

使代码编译的一种方法是显式捕获[&one...]，但是我想知道这是否是clang中的错误。

也很有趣：将return语句更改one为直接扩展的内容（与结合之前two），然后再次编译： return (((one * ...) * two) + ...);

我找到了这个相关的帖子，但是声明在那里的错误似乎在clang8中已修复。

指定的初始化程序（C ++ 20）应该如何与CTAD一起使用？

这段代码在gcc9.2中可以正常工作，但在clang8中失败

template <typename int_t=int, typename float_t=float>
struct my_pair {
    int_t   first;
    float_t second;
};

template<typename ... ts>
my_pair(ts...) -> my_pair<ts...>;

int main() {
    my_pair x{.first = 20, .second = 20.f};
    static_assert( std::is_same_v<decltype(x.first), int> );
    static_assert( std::is_same_v<decltype(x.second), float> );
}

这应该是有效的吗？

参见https://godbolt.org/z/KtNI43上的示例

我已经在这个问题中对使用指定的初始化程序的CTAD感到困惑，但是我对另一个非常相似的代码段也感到困惑

template <typename int_t=int, typename float_t=float>
struct my_pair {
    int_t   first;
    float_t second;
};

template<typename ... ts>
my_pair(ts...) -> my_pair<ts...>;

int main() {
    my_pair x{.second = 20.f};
    static_assert( std::is_same_v<decltype(x.first), int> ); //FAILS <- its deduced to float
    static_assert( std::is_same_v<decltype(x.second), float> );
}

即使我没有在指定的初始值设定项中给出显式信息，推论指南似乎也将推导类型first推导为。无论关键字（），推论指南显然只关心初始化程序中的顺序。演绎指南应该明智吗？还是应该有一个“指定演绎指南”？float.first.second

请参阅https://godbolt.org/z/cm6Yi7上的示例

请考虑以下codesnippet:

#include <iostream>
#include <condition_variable>
#include <chrono>
#include <mutex>

int main () {
  std::mutex y;
  std::condition_variable x;
  std::unique_lock<std::mutex>lock{y};
  int i = 0;
  auto increment = [&] {++i; return false;};
  using namespace std::chrono_literals;

  //lock 5s if increment returns false
  //let's see how often was increment called?
  x.wait_for(lock, 5s, increment);
  std::cout << i << std::endl;

  //compare this with a simple loop:
  //how often can my system call increment in 5s?
  auto const end = std::chrono::system_clock::now() + 5s;
  i = 0;
  while (std::chrono::system_clock::now() …

考虑2个片段:

using x = int*;

int main () {
  const x a = new int(3);
  *a = 5;
}

和

int main () {
  const int* a = new int(3);
  *a = 5;
}

第一个编译,而第二个没编译

- > using不等于简单地"插入"类型然后解析该行.

using直接使用和"内联"类型之间是否存在更多差异？

为什么标准允许我的编译器应用复制省略，即使它涉及可见的副作用，从而打破了 as-if 规则？

当一个人保证复制省略时，这对我来说是有道理的，因为复制/移动的实际功能（这将调用程序行为的可见变化）不一定存在，但为什么/如何在 C+ 之前+17？

是不是因为编译器一般不能检测副作用（不知道是否可行）？