如何使我的类免疫 C + + 中的“ auto value = copy of xy”地雷？

小开

是的，这确实是个问题。在当前的 C + + (编写本文时为 C + + 20)中，除了在调用站点更改代码之外，没有其他解决方案。

有一个建议 P0672R0“自动”变量的隐式评价(从2017年开始)试图处理这个确切的问题。它使用数学库中的代理类作为例子，就像你的案例一样，并给出了 std::vector<bool>的例子，就像你的案例一样。它给出了从这个模式中产生的问题的更多例子。

该文件提出了3种解决方案，都是用语言实现的:

运算符号:

class product_expr
{
matrix operator auto() { ... }
};

使用声明:

class product_expr
{
using auto = matrix;
};

腐烂的专业化:

使 auto x= expr被定义为 typename std::decay<decltype(expr)>::type x=expr;，然后使用可以专门化 std::decay

标准委员会会议的讨论强烈支持使用宣言解决方案。然而，我无法找到更多关于这篇文章的更新，所以我个人认为在不久的将来，这篇文章或类似的东西不会在语言中实现。

因此，不幸的是，现在您唯一的解决方案是向用户介绍库使用的代理类。

小开

通过在代理类的操作符 = 的末尾添加“ & &”来减少损害

(和运算符 + = ,-= 等)

我做了很多实验，但最终我找到了一种方法来缓解这个问题最常见的情况，这种方法可以收紧代理，因此你仍然可以复制代理，但是一旦你把它复制到一个堆栈变量，你就不能修改它，并且无意中破坏了源容器。

#include <cstdio>
#include <utility>


auto someComplexMethod()
{
struct s
{
void operator=(int A)&& {std::printf("Setting A to %i", A);}
};
return s();
}


int main()
{
someComplexMethod() = 4; // Compiles. Yay


auto b = someComplexMethod();
// Unfortunately that still compiles, and it's still taking a
// copy of the proxy, but no damage is done yet.


b = 5;
// That doesn't compile. Error given is:
//   No overload for '='  note: candidate function not viable:
//   expects an rvalue for object argument


std::move(b) = 6;
// That compiles, but is basically casting around the
// protections, aka shooting yourself in the foot.
}

小开

我有一个模糊的想法，不确定它是否实用。它不覆盖 auto推断的内容(这似乎是不可能的) ，而只是导致将代理复制到格式不正确的变量。

使代理不可复制。
仅此一点并不能阻止您将代理保存到 auto变量，因为 RVO 是强制的。为了抵消这种影响，应该通过引用返回代理。
为了避免获得悬空引用，可以在默认函数参数中构造代理，该参数的生存期与正则参数相同，直到完整表达式结束为止。
用户仍然可以将 参考文献保存到代理。为了使这种误用更加困难，您可以返回一个右值引用，并且 &&限定所有成员函数。
这可以防止与悬空代理引用进行任何交互，除非您将其 std::move。这应该足够模糊，以阻止您的用户，但如果没有，您将不得不依靠一些消毒剂或设置一个(易失性?)在代理的析构函数中标记，并在每次访问它时检查它(这是 UB，但应该足够可靠)。

例如:

namespace impl
{
class Proxy
{
Proxy() {}
public:
static Proxy construct() {return {};}
Proxy(const Proxy &) = delete;
Proxy &operator=(const Proxy &) = delete;
int *ptr = nullptr;
int operator=(int value) && {return *ptr = value;}
};
}


impl::Proxy &&make_proxy(int &target, impl::Proxy &&proxy = impl::Proxy::construct())
{
proxy.ptr = &target;
return std::move(proxy);
}

然后:

int x = 0;
make_proxy(x) = 1; // Works.
auto a = make_proxy(x); // error: call to deleted constructor of 'impl::Proxy'
auto &b = make_proxy(x); // error: non-const lvalue reference to type 'impl::Proxy' cannot bind to a temporary of type 'impl::Proxy'
const auto &c = make_proxy(x); // Compiles, is a dangling reference. BUT!
c = 2; // error: no viable overloaded '='
auto &&d = make_proxy(x); // Compiles, is a dangling reference.
d = 3; // error: no viable overloaded '='
std::move(d) = 2; // Compiles, causes UB. Needs a runtime check.

使用重载操作符(除了 ())不能使用默认参数，这很难实现，但仍然是可行的:

namespace impl
{
struct Index
{
int value = 0;
Proxy &&proxy;
Index(int value, Proxy &&proxy = Proxy::construct()) : value(value), proxy(std::move(proxy)) {}
Index(const Index &) = delete;
Index &operator=(const Index &) = delete;
};
}


struct B
{
int x = 0;
impl::Proxy &&operator[](impl::Index index)
{
index.proxy.ptr = &x;
return std::move(index.proxy);
}
};

唯一的缺点是，因为对于任何参数，最多只允许一个用户定义的隐式转换，所以这个 operator[]只能用于 int参数，而不能用于具有 operator int的类。

如何使我的类免疫 C + + 中的“ auto value = copy of xy”地雷？

我怎样才能使我的库对这个陷阱免疫? (不改变客户端代码!)

通过在代理类的操作符 = 的末尾添加“ & &”来减少损害