小编Ziz*_*Tai的帖子

我试图实现std::optional与constexpr支持的做法。用法类似于：

constexpr optional<int> x(123);
int arr[*x];

在尝试实现这一点时，我遇到了一个无法解决的问题：在optional<T>对象内部，我使用一个std::aligned_storage_t<sizeof (T), alignof (T)>对象来存储值，并使用 new inoptional<T>的构造函数将值构造到存储中。但是placement new 不能在constexpr构造函数中使用：

constexpr optional(const T& value)
    noexcept(std::is_nothrow_copy_constructible<T>::value)
    : ...
{
    new (ptr_to_storage) T(value);  // this breaks `constexpr`
}

我还能如何实现这一点？

让我们调用一个看起来像T<Us...>一个更高级的类型的类型.对于某种更高级的类型SomeType(让我们说它是std::vector<int>),我想使用类型特征从中提取Tpart(std::vector).我可以这样做:

template<typename>
struct HKT;

template<template <typename...> class T, typename... Us>
struct HKT<T<Us...>> {
    template<typename... Vs>
    using type = T<Vs...>;
};

所以现在我可以做HKT<SomeType>::type<Foo>一个定义std::vector<Foo>.

但我正试图摆脱这::type部分,就像typename std::enable_if<T>::type可以缩写为std::enable_if_t<T>.不确定是否可能,因为在我的情况下HKT_t<SomeType>(假设它存在)将是别名模板而不是类型.用法就像HKT_t<SomeType><Foo>......我猜这真的是一个"别名模板模板".

我想这样做的原因是使用它作为模板模板参数的参数.例如,

template<template <typename...> class T>
void foo() {...}

foo<HKT_t<std::vector<int>>>();

那可能吗？

&MUI 函数中 CSS 选择器之前何时需要使用 & 符号 ( ) styled？例如，以下两个版本的工作方式似乎相同：

// With ampersand
const CssTextField = styled(TextField)({
  '& label.Mui-focused': {
    color: 'green',
  },
  '& .MuiInput-underline:after': {
    borderBottomColor: 'green',
  },
  '& .MuiOutlinedInput-root': {
    '& fieldset': {
      borderColor: 'red',
    },
    '&:hover fieldset': {
      borderColor: 'yellow',
    },
    '&.Mui-focused fieldset': {
      borderColor: 'green',
    },
  },
});

// Without ampersand sometimes
const CssTextField = styled(TextField)({
  "label.Mui-focused": {
    color: "green"
  },
  ".MuiInput-underline:after": {
    borderBottomColor: "green"
  },
  "& .MuiOutlinedInput-root": {
    fieldset: {
      borderColor: "red"
    },
    ":hover …

如本页所述，

std::nullopt_t必须是 aLiteralType并且不能有默认构造函数。它必须有一个constexpr构造函数，该构造函数采用某种实现定义的文字类型。...注释 nullopt_t不DefaultConstructible支持op = {};和op = nullopt;作为脱离可选对象的语法。

...而且，一个可能的实现是

struct nullopt_t {
    constexpr nullopt_t(int) {}
};

实际上，在阅读本文后，我不太明白其背后的原理。

(1) 为什么nullopt_t不做DefaultConstructible？我不太明白“......支持两者......”部分。

(2) 为什么可能的构造函数采用int，而boost::none_t采用空类型boost::none_t::init_tag？这两种实现有何不同？

我正在设计一个实用程序来创建一个类似元组的对象的视图.目标是启用这样的代码:

// make_tuple_view<Is...>(t): view of t's elements at positions Is...

auto t = std::make_tuple(42, 'c', 3.14);
auto tv = make_tuple_view<2, 1, 0, 1>(t);  // tv == (3.14, 'c', 42, 3.14)
++std::get<0>(tv);
// tv == (4.14, 'c', 42, 4.14)
// t  == (42, 'c', 4.14)

因此元组视图的元素类型是对原始元组中相应元素的适当类型的引用.目前,这是我推断引用类型的方式:

#include <tuple>
#include <utility>

namespace detail {

template<std::size_t FromIndex, std::size_t... Is, typename Tuple>
constexpr auto make_tuple_range_impl(std::index_sequence<Is...>,
                                     Tuple&& t) noexcept
{
    return std::forward_as_tuple(
            std::get<FromIndex + Is>(std::forward<Tuple>(t))...);
}

}  // namespace detail

// make_tuple_range
template<std::size_t …

鉴于一些现有的仿函数:

struct incr {
    int operator()(int x) const { return x + 1; }
};

struct rep_str {
    std::string operator()(const std::string& s) const { return s + s; }
};

我想知道是否有可能实现这样的目标:

auto f = overload<incr, rep_str>();
f(1);        // returns 2
f("hello");  // returns "hellohello"

多次重载可能如下所示:

auto f = overload<fa, fb, fc, ...>();
// or...
auto g = overload<fa, overload<fb, overload<fc, ...>>>();

我想也许可以使用SFINAE std::result_of_t或类似的东西,但还没弄明白怎么做.

除了求助之外，还有没有其他方法可以存储同类的可调用对象集合std::function？即，T在以下代码中替换类型

using T = std::function<void(int)>;
std::vector<T> v{some_lambda, some_fn_ptr, some_pmf, some_functor};

还有别的吗？

当将各个可调用对象作为高阶函数的参数传递时，我尽可能使用template以避免的开销std::function。但是对于收藏，我不知道有什么我可以做的。

我注意到这两个views.html.myView.render(...),views.html.myView(...)可以用来从模板生成一个页面.但是,如果我们需要将隐式参数列表传递到视图中,则似乎只有apply版本在render版本不编译时才有效.

我假设views.html.myView.apply可能代表views.html.myView.render(或反过来)幕后,但我不确定,也无法在文档中找到与此相关的任何内容.我从Twirl文档中得到的唯一一点是TemplateNtraits都定义了render方法,但没有一个提到apply.

考虑以下简单的引用计数函数（与 一起使用boost::intrusive_ptr）：

class Foo {\n    // ...\n\n    std::atomic<std::size_t> refCount_{0};\n\n    friend void intrusive_ptr_add_ref(Foo* ptr)\n    {\n        ++ptr->refCount_;  // \xe2\x9d\xb6\n    }\n\n    friend void intrusive_ptr_release(Foo* ptr)\n    {\n        if (--ptr->refCount_ == 0) {  // \xe2\x9d\xb7\n            delete ptr;\n        }\n    }\n};\n

我仍在学习内存排序，我想知道在这种情况下fetch_add/sub( memory_order_seq_cst) 的默认内存排序是否太严格。由于我想确保的唯一顺序是在 \xe2\x9d\xb6 和 \xe2\x9d\xb7 之间，我认为我们可以将 \xe2\x9d\xb6 替换为

ptr->refCount_.fetch_add(1, std::memory_order_release);\n

和 \xe2\x9d\xb7 与

if (ptr->refCount_.fetch_sub(1, std::memory_order_consume) == 1) {\n

但内存排序对我来说仍然是新的和微妙的，所以我不确定这是否能正常工作。我错过了什么吗？

我写了一个Rust程序,它生成小写英文字母的所有两个字母的排列("aa","ab",...,"zy","zz"):

fn main() {
    static ASCII_LOWER: [char; 26] = [
        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
    ];

    let x: Vec<_> = ASCII_LOWER.iter().flat_map(|a| {
        let result = ASCII_LOWER.iter().map(move |b| {
            format!("{}{}", a, b)
        });

        dbg!(a);  // <--- How can `a` still be used?

        result
    }).collect();

    dbg!(x);
}

我需要将内部封闭标记为move,因为否则所捕获的借用a不够长.但是,move在这种情况下,我不明白这实际上是做什么的.a关闭后我仍然可以使用.什么是move真正在这里做？