小编Fur*_*ish的帖子

受此答案的启发,我尝试复制并粘贴(并添加测试main())此代码:

template<typename T>
std::tuple<int, double> foo(T a) {
    if constexpr (std::is_same_v<int, T>)
        return {a, 0.0};
    else if (std::is_same_v<double, T>)
        return {0, a};
    else
        return {0, 0.0};
}

int main() {
    auto [x, y] = foo("");
    std::cout << x << " " << y;
}

这非常简单 - 如果T推断为int,我们想要返回一个元组[a, 0.0].如果T推断为double,我们想要返回一个元组 [0, a].否则,我们想要回来[0, 0.0].

正如你所看到的,在main()函数中,我foo用const char*参数调用,这应该导致x和 …

在这个答案中，我们可以看到：

我猜想using '\n'或using 之间没有什么区别"\n"，但是后者是一个（两个）字符的数组，必须逐个字符地打印，为此必须建立一个循环，这比输出单个字符更为复杂。。

^重点矿

这对我来说很有意义。我认为，输出const char*需要一个循环，这将测试空终止符，其必须推出比更多的操作，比方说，一个简单的putchar（不是暗示std::cout与char代表们呼吁-它只是引进一个实例的简化）。

说服我使用

std::cout << '\n';
std::cout << ' ';

而不是

std::cout << "\n";
std::cout << " ";

在这里值得一提的是，我知道性能差异几乎可以忽略不计。但是，有些人可能会争辩说，前一种方法的意图是实际上传递单个字符，而不是恰好是一个char长字符（如果算上是2 char s '\0'）的字符串文字。

最近，我为使用后一种方法的人做了一些代码修改。我对此案发表了一点评论，然后继续。然后，开发人员感谢我，并说他甚至都没有想到这种差异（主要集中在意图上）。完全没有影响（毫不奇怪），但是采用了更改。

然后，我开始怀疑这种变化到底有多重要，所以我狂奔。令我惊讶的是，当在带有标志的GCC（树干）上进行测试时，它显示出以下结果-std=c++17 -O3。为以下代码生成的程序集：

#include <iostream>

void str() {
    std::cout << "\n";
}

void chr() {
    std::cout << '\n';
}

int main() {
    str();
    chr();
}

我很惊讶，因为看起来chr() …

我碰到一个std::shared_mutex在C++17.究竟是什么std::shared_mutex以及它与众不同std::mutex？

我遇到的问题发生在我试图测试生成伪随机数的cppreference示例时.举个例子:

#include <iostream>
#include <random>

int main() {
    std::random_device rd{};
    std::mt19937 gen{rd()};
    std::uniform_int_distribution<> dis{1, 6};

    for(int n = 0; n < 10; ++n) {
        std::cout << dis(gen) << ' ';
    }
    std::cout << '\n';
}

在我的机器上,它会导致崩溃.通过"崩溃"我的意思是该过程只是挂起并0xC0000005在几秒钟后返回.

我想知道是什么原因造成的.GCC错误？我的机器出现故障？我决定测试,结果非常令人惊讶.例如,给出以下略微修改的示例:

#include <iostream>
#include <random>

int main() {
    std::random_device rd{};
    std::mt19937_64 gen{rd()}; // notice the _64 here
    std::uniform_int_distribution<> dis{1, 6};

    for(int n = 0; n < 10; ++n) {
        std::cout << dis(gen) << ' ';
    }
    std::cout << '\n';
} …

考虑到这个看起来很傻的try-catch链条：

try {
    try {
        try {
            try {
                throw "Huh";
            } catch(...) {
                std::cout << "what1\n";
            }
        } catch(...) {
            std::cout << "what2\n";
        }
    } catch(...) {
        std::cout << "what3\n";
    }
} catch(...) {
    std::cout << "what4\n";
}

它的输出肯定是（并且是）what1，因为它将被最接近的匹配捕获catch。到现在为止还挺好。

但是，当我尝试为尝试通过成员初始化列表（这将导致引发异常）初始化成员的类创建构造函数时，如下所示：

int might_throw(int arg) {
    if (arg < 0) throw std::logic_error("que");
    return arg;
}

struct foo {
    int member_;

    explicit foo(int arg) try : member_(might_throw(arg)) {

    } catch (const std::exception& ex) { …

我正在尝试使用 Java StreamsString从我的列表中收集最大长度的所有s：

List<String> strings = Arrays.asList("long word", "short", "long wwww", "llll wwww", "shr");

List<String> longest = strings.stream()
            .sorted(Comparator.comparingInt(String::length).reversed())
            .takeWhile(???)
            .collect(Collectors.toList());

我希望 mylongest包含{"long word", "long wwww", "llll wwww"}，因为那些是String具有最大长度的s。如果只有String最大长度的s之一，我显然希望结果List只包含该元素。

我试图首先对它们进行排序，以便在第一个元素中出现最大长度，但我无法检索流中第一个元素的长度。我可以尝试类似的东西peek()：

static class IntWrapper {
    int value;
}

public static void main(String[] args) throws IOException {
    List<String> strings = Arrays.asList("long word", "short", "long wwww", "llll wwww", "shr");

    IntWrapper wrapper = new IntWrapper();

    List<String> longest = strings.stream()
            .sorted(Comparator.comparingInt(String::length).reversed())
            .peek(s …

看到这个答案后，我试图为它的代码提供一个变量模板实用程序：

template <class T, template <class...> class Template>
struct is_specialization : std::false_type {};

template <template <class...> class Template, class... Args>
struct is_specialization<Template<Args...>, Template> : std::true_type {};

并像这样实现它：

template <template <class...> class Template, class... Args>
constexpr bool is_specialization_v = is_specialization<Template<Args...>, Template>::value;

因为这就是我看到要在的头文件中实现类似的实用程序的方式<type_traits>。例如：

template <typename _Tp, typename _Up>
  inline constexpr bool is_same_v = is_same<_Tp, _Up>::value;
template <typename _Base, typename _Derived>
  inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
template <typename _From, typename _To>
  inline constexpr bool is_convertible_v …

我想创建一个deep_flatten函数模板，它会产生一个range深度join编辑的元素。例如，如果我们只考虑嵌套的std::vectors，我可以有：

template <typename T>
struct is_vector : public std::false_type { };

template <typename T, typename A>
struct is_vector<std::vector<T, A>> : public std::true_type { };

template <typename T>
auto deepFlatten(const std::vector<std::vector<T>>& vec) {
    using namespace std::ranges;
    if constexpr (is_vector<T>::value) {
        auto range = vec | views::join;
        return deepFlatten(std::vector(range.begin(), range.end()));
    } else {
        auto range = vec | views::join;
        return std::vector(range.begin(), range.end());
    }
}

这使我能够做到：

std::vector<std::vector<std::vector<int>>> nested_vectors = {
        {{1, 2, 3}, {4, 5}, …

在cppreference on 上std::ranges::less，在注释中我们可以看到：

不像std::less，std::ranges::less需要所有六个比较运算<，<=，>，>=，==和!=是（通过有效的totally_ordered_with约束）。

但为什么？我们为什么要使用std::ranges::less{}而不是std::less{}？less{}仅当定义了其他比较运算符而不仅仅是<一个比较运算符时，我们才想要的实际情况是什么？

假设我想从中删除唯一元素std::vector（不消除重复项，而仅保留至少出现2次的元素），并且我想以一种非常低效的方式实现这一点-通过std::count在std::remove_ifing时调用。考虑以下代码：

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 6, 3, 6, 2, 7, 4, 4, 5, 6};

    auto to_remove = std::remove_if(vec.begin(), vec.end(), [&vec](int n) {
        return std::count(vec.begin(), vec.end(), n) == 1;
    });

    vec.erase(to_remove, vec.end());

    for (int i : vec) std::cout << i << ' ';
}

从参考开始，std::remove_if我们知道从开始的元素to_remove具有未指定的值，但是我想知道它们到底有多未指定。

为了解释我所关心的远一点-我们可以看到，应删除的元素是1，3，5和7-唯一的唯一值。std::remove_if会将移至 …