小编Vit*_*meo的帖子

在一个内部更新值(给定键和新值)的规范方法是boost::hana::map什么？

我尝试使用boost::hana::replace_if但它不起作用,map因为它不是Functor- 我可以通过将其转换map为a tuple然后再转换为a 来实现map它,但听起来效率低下.

我目前正在使用的替代方案是调用map::erase_key后跟map::insert.

是否有任何replace或update为此目的而设计的功能可能会丢失？或者这是更新价值的"规范"方式？

我正在尝试检测可调用对象是否为二进制(即,它是否operator()采用两个参数).我想对lambdas执行此检查,包括泛型lambdas和约束泛型lambda (例如,使用尾随std::enable_if_t返回类型).

注意:这不是"普通lambda的arity"的副本.我只关心检查泛型lambda是否是二进制的,并且我已经可以为不受约束的泛型lambda或不使用其体中的参数的泛型lambda做到这一点.

我目前的方法是应用Kris Jusiak的Boost.DI C++ Now 2015谈话中描述的技术之一:any_type.它基本上是一个可以隐式转换为任何其他类的类.

struct any_type
{
    template <typename T>
    constexpr operator T() const noexcept
    {
        return {};
    }
};

在定义之后any_type,我正在使用检测习惯来检查是否可以使用两个参数调用特定的可调用对象:

template<class T>
using is_binary_callable_impl = decltype(std::declval<T>()(any_type{}, any_type{}));

template <typename T>
using is_binary_callable = std::experimental::is_detected<is_binary_callable_impl, T>;

这种方法适用于非泛型和通用lambda ...

auto unary_nongeneric = [](int){};
auto unary_generic = [](auto){};
auto binary_nongeneric …

(使用g++ 7.0trunk.)

鉴于以下"类型到价值包装"实用程序......

template <typename T>
struct type_wrapper { using type = T; };

// "Wraps" a type into a `constexpr` value.
template <typename T>
constexpr type_wrapper<T> type_c{};

...我创建了以下函数来检查表达式的有效性:

template <typename TF>
constexpr auto is_valid(TF)
{
    return [](auto... ts) constexpr 
    {
        return std::is_callable<TF(typename decltype(ts)::type...)>{};
    };
}   

该is_valid功能可以使用如下:

// Evaluates to `true` if `some_A.hello()` is a valid expression.
constexpr auto can_add_int_and_float = 
    is_valid([](auto _0) constexpr -> decltype(_0.hello()){})
        (type_c<A>);

// Evaluates to `true` if `some_int + some_float` is …

我正在尝试构建一系列可调用对象，以便稍后异步执行。我想尝试以下方法：构建节点的“嵌套”结构（通过将每个节点移动到其“父节点”中），从而生成一个存储所有计算并可以按需启动链的对象。

这就是我的想法：

template <typename TParent, typename TF>
struct node
{
    TParent _parent;
    TF _f;

    node(TParent&& parent, TF&& f) 
        : _parent{std::move(parent)}, _f{std::move(f)}
    {
    }

    template <typename TFContinuation>
    auto then(TFContinuation&& f_continuation)
    {
        using this_type = node<TParent, TF>;
        return node<this_type, std::decay_t<TFContinuation>>
            {std::move(*this), std::move(f_continuation)};
//           ^^^^^^^^^^^^^^^^
//           ...safe?
    }   
};

上面的代码允许用户编写如下所示的链：

int main()
{
    node n{some_root_callable, []{/*...*/}};
    n.then([]{/*...*/})
     .then([]{/*...*/})
     .then([]{/*...*/})
     .then([]{/*...*/});
}

（真正的实现将支持更有用的抽象，例如when_all(...)或when_any(...)。）

魔盒示例。

假设TParent、TF、 和TFContinuation是可移动的可调用对象，那么在 的调用期间调用是否安全（即明确定义） …

是否可以在一个成员函数的定义中为类使用类模板参数推导？...或者我被迫在C++ 03中编写我的助手类？CCmake_c

考虑这种最小化和简化的场景,它构建了一系列任意函数对象:

template <typename F>
struct node;

template <typename FFwd>
node(FFwd&&) -> node<std::decay_t<FFwd>>;

在node类存储它通过完美转发初始化函数对象.我需要一个演绎指南,指向decay函数对象的类型.

template <typename F>
struct node
{
    F _f;

    template <typename FFwd>
    node(FFwd&& f) : _f{std::forward<FFwd>(f)}
    {
    }

    template <typename FThen>
    auto then(FThen&& f_then)
    {
        return node{[f_then = std::move(f_then)]
                    { 
                        return f_then(); 
                    }};
    }
};

然后,我定义了node构造函数和一个.then返回一个新节点的continuation成员函数(它的实现是无意义的,以最小化示例的大小).如果我试图调用.then......

auto f = node{[]{ return 0; }}.then([]{ return 0; });

...我收到一个意外的编译错误: …

我正在尝试创建一个从a std::map或an 获取键的函数std::unordered_map。我可以使用简单的重载，但首先我想知道这段代码有什么问题。

template<typename K, typename V, template<typename, typename> class TContainer>  
std::vector<K> getKeys(const TContainer<K, V>& mMap)
{
    std::vector<K> result;
    for(const auto& itr(std::begin(mMap)); itr != std::end(mMap); ++itr) result.push_back(itr->first);
    return result;
}

当使用调用它时std::unordered_map，即使手动指定所有模板类型名称，clang ++ 3.4 也会说：

template template参数的模板参数与其对应的模板template参数不同。

我发现(感谢StackOverflow注释)我的代码中存在安全漏洞:

std::vector<std::unique_ptr<Item>> items;

template<class... TS> Item& create(TS&&... mArgs)
{
    auto item(new Item(std::forward<TS>(mArgs)...);
    items.emplace_back(item); // Possible exception and memory leak
    return *item;
}

基本上,如果抛出Item,使用raw 分配new可能会泄漏内存emplace_back.

解决方案永远不会使用raw new,而是std::unique_ptr在方法体中使用right.

std::vector<std::unique_ptr<Item>> items;

template<class... TS> Item& create(TS&&... mArgs)
{
    auto item(std::make_unique<Item>(std::forward<TS>(mArgs)...);
    items.emplace_back(std::move(item));
    return *item; // `item` was moved, this is invalid!
}

正如你所看到的,返回item是无效的,因为我不得不item使用std::move它来将它放入items容器中.

我想不出一个需要item在另一个变量中存储地址的解决方案.然而,原始(错误)解决方案非常简洁易读.

是否有更优雅的方式返回std::unique_ptr被移动到容器中的位置？

假设我有一个容器对象来存储std::vector多态子.

struct Child
{
    Child(Parent& mParent) { /* ... */ }
    virtual ~Child() { }
};

class Parent
{
    private:
        std::vector<std::unique_ptr<Child>> children;

        template<typename T, typename... TArgs> 
        auto& mkChild(TArgs&&... mArgs)
        {
            // `static_assert` that `T` is derived from `Child`...
            children.emplace_back(std::make_unique<T>(std::forward<TArgs>(mArgs)...));
            return *children.back();
        }

    public:
        template<typename T, typename... TArgs> 
        auto& add(TArgs&&... mArgs)
        {
            mkChild<T>(std::forward<TArgs>(mArgs)...));
            return *this;
        }
};

现在我可以使用这样的Parent类:

int main()
{
    Parent p;
    p.add<Child1>(some_args1).add<Child2>(some_args2);
}

虽然这种语法实现了我想做的事情(将子项添加到单个父项中),但我觉得很难阅读,特别是在我的实际用例中.

我真的很想用operator<<.但我无法想出一种方法来构建孩子.

// Desired syntax
int main()
{
    Parent p; …

我正在尝试使用Boost.Sprit x3将两个整数的序列匹配成一个std::pair<int, int>.根据文档判断,以下代码应该编译:

#include <string>
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/home/x3.hpp>

int main()
{
    using namespace boost::spirit::x3;

    std::string input("1 2");
    std::pair<int, int> result;
    parse(input.begin(), input.end(), int_ >> int_, result);
}

melpon.org链接

但是,它只匹配第一个整数.如果我改变std::pair<int, int> result;对int result;,然后打印result,我得到1我的输出.

为什么会这样？这不是int_ >> int_定义匹配(并设置为属性)两个整数的解析器的正确方法吗？

我了解 Editions 的目标以及如何使用它们，但文档并没有说明它们的内部工作原理。

假设我有两个源文件：

• old.rs，针对 Rust 2015；

• new.rs，针对 Rust 2018。

我想构建一个同时使用它们的应用程序。正在使用什么机制来确保它们可以互操作？

两者都做old.rs，并new.rs会转换为相同型号HIR？或者均质化发生在此之前（例如 AST 水平）还是之后（例如 MIR 水平）？