小编0xb*_*00d的帖子

20.6.9:

void deallocate(pointer p, size_type n);

• 要求:p应为从allocate()获得的指针值.n应该将作为第一个参数传递的值等于返回p的allocate的调用.
• 效果:释放p引用的存储.
• 备注:使用:: operator delete(void*)(18.6.1),但在调用此函数时未指定.

如果n不等于作为第一个agrgument传递给返回的allocate调用的值,会发生什么p？不解除分配？扔std::bad_alloc？...

编辑: 我实际上对"应该发生什么"的意思是:在自定义实现中抛出或断言是否可以？

我们如何使用std::transform,如果我们不希望每个元素转变成一个变换元素,但2？

以下伪代码说明了我想要实现的目标

std::transform(a.cbegin(), a.cend(), std::back_inserter(b), [](T const& x) {
    return f(x) and g(x);
});

当然,我可以调用std::transform两次,但那会很烦人.也许我们需要提供一个自定义插件.还有其他选择吗？

假设我们可以证明一个用大小输入调用的算法n及时运行O(f(n)).

我想证明这个运行时限很紧.两个问题:

1. 提供特殊输入并显示运行时间至少是不够的f(n)？
2. 我已经读过,证明紧张的一种可能性是"减少排序".我不知道那是什么意思

令为四叉树N中的内部节点数。为什么叶子的数量等于？我不明白我们需要如何争论。1 + 3 * N

我想做类似以下代码的事情:

class foo
{
private:
    std::fstream* m_stream;

public:
    foo(std::fstream* stream) : m_stream(stream) { }

    foo& write(char const* s, std::streamsize count)
    {
        if (/*condition*/)
        {
            m_stream->write(s, count);
        }
        else
        {
            // ...
        }

        return *this;
    }

    foo& read(char* s, std::streamsize count)
    {
        if (/*condition*/)
        {
            m_stream->read(s, count);
        }
        else
        {
            // ...
        }

        return *this;
    }
};

我需要为所有类似的方法添加相同的行为(例如put).这不应仅适用于文件流,而应适用于所有其他流类.有没有简单的方法来允许这些功能？

我需要对无法放入内存的巨大二进制文件进行排序。无法使用排序算法并从 I/O 设备连续读/写。有没有可能使用内存映射文件之类的东西？

根据我的理解，将处理程序发布到strand对象意味着：

• 一次只执行一个已发布的处理程序。
• 处理程序按顺序调用。

将处理程序直接发布到io_service对象并将它们包装起来strand::wrap也意味着一次只执行一个已发布的处理程序，但不是按顺序执行的。

还有其他区别吗？以及如何使用 并行（在不同线程中）运行两种（或更多）不同类型的工作（因此，不同的处理程序/函数）strand？

请考虑以下代码：

using custom_t = std::valarray<unsigned>;
custom_t o;
unsigned acc = std::accumulate(std::cbegin(o), std::cend(o), 0);

g++-5 说

没有匹配的函数调用 cbegin(custom_t&)

如果我使用std::begin(o)andstd::end(o)代替，一切正常。这是编译器错误吗？代码使用 Visual Studio 2015 编译。

给定（简化的）检测习惯用法的实现

namespace type_traits
{
    template<typename... Ts>
    using void_t = void;

    namespace detail
    {
        template<typename, template<typename...> class, typename...>
        struct is_detected : std::false_type {};

        template<template<class...> class Operation, typename... Arguments>
        struct is_detected<void_t<Operation<Arguments...>>, Operation, Arguments...> : std::true_type {};
    }

    template<template<class...> class Operation, typename... Arguments>
    using is_detected = detail::is_detected<void_t<>, Operation, Arguments...>;

    template<template<class...> class Operation, typename... Arguments>
    constexpr bool is_detected_v = detail::is_detected<void_t<>, Operation, Arguments...>::value;
}

我们可以检查一个类是否foo包含一个成员函数bar

struct  foo {
    int const& bar(int&&) { return 0; }
};

template<class T, typename... Arguments> …

请考虑以下tree课程

template<typename T, template<typename> class Tuple>
class tree
{
private:
    T m_value;
    Tuple<tree> m_children;
};

template<typename T, std::size_t N>
using static_tree = tree<T, std::array<T, N>>;

这没有明确的定义.std::array<T, N>不适合的模板参数Tuple.我认为这static_tree是明确的意图.我们可以做点什么

template<std::size_t N>
struct helper
{
    template<typename T>
    using type = std::array<T, N>;
};

template<typename T, std::size_t N>
using static_tree = tree<T, helper<N>::template type>;

没有helper班级还有其他选择吗？