是否可以通过const引用获取参数，同时禁止转换以便不传递临时值？

Question

有时我们喜欢通过引用获取一个大参数，并且如果可能的话也使参考const宣称它是一个输入参数。 但是通过制作引用const，编译器然后允许自己转换数据，如果它是错误的类型。 这意味着它不那么有效，但更令人担心的是我认为我指的是原始数据; 也许我会接受它的地址，而不是意识到我实际上是在接受一个临时的地址。

此代码中对bar的调用失败。 这是可取的，因为引用的类型不正确。 对bar_const的调用也是错误的类型，但它默默地编译。 这对我来说是不受欢迎的。

#include<vector>
using namespace std;

int vi;

void foo(int &) { }
void bar(long &) { }
void bar_const(const long &) { }

int main() {
   foo(vi);
   // bar(vi); // compiler error, as expected/desired
   bar_const(vi);
}

传递轻量级只读引用最安全的方法是什么？ 我很想创建一个类似于参考的新模板。

（显然， int和long是非常小的类型。但是我已经遇到了可以相互转换的更大的结构。我不希望这在我采用const引用时默默地发生。有时，标记构造函数作为显式帮助，但这并不理想）

更新：我想象一个如下系统：想象一下有两个函数X byVal(); 和X& byRef(); 以及以下代码块：

 X x;
 const_lvalue_ref<X> a = x; // I want this to compile
 const_lvalue_ref<X> b = byVal(); // I want this to fail at compile time
 const_lvalue_ref<X> c = byRef(); // I want this to compile

该示例基于局部变量，但我希望它也可以使用参数。 我希望得到某种错误消息，如果我不小心将ref-to-temporary或ref-to-a-copy传递给我认为我会传递一些轻量级的内容，例如ref-to-lvalue。 这只是一个'编码标准'的东西 - 如果我真的想允许将ref传递给临时的，那么我将使用简单的const X& 。 （我在Boost的FOREACH上发现这篇文章非常有用。）

Answer 1

好吧，如果你的“大参数”是一个类，首先要做的是确保你明确标记任何单个参数构造函数（除了复制构造函数）：

class BigType
{
public:
    explicit BigType(int);
};

这适用于具有可能使用单个参数调用的默认参数的构造函数。

然后它将不会自动转换为，因为没有隐式构造函数供编译器用于执行转换。 您可能没有任何构成该类型的全局转换运算符，但如果您这样做，那么

如果这对您不起作用，您可以使用一些模板魔术，例如：

template <typename T>
void func(const T &); // causes an undefined reference at link time.

template <>
void func(const BigType &v)
{
    // use v.
}

Answer 2

如果您可以使用C ++ 11（或其中的一部分），这很容易：

void f(BigObject const& bo){
  // ...
}

void f(BigObject&&) = delete; // or just undefined

Ideone上的实例 。

这将起作用，因为绑定到rvalue ref优先于绑定到临时对象的reference-to-const。

您还可以利用隐式转换序列中仅允许单个用户定义转换的事实：

struct BigObjWrapper{
  BigObjWrapper(BigObject const& o)
    : object(o) {}

  BigObject const& object;
};

void f(BigObjWrapper wrap){
  BigObject const& bo = wrap.object;
  // ...
}

Ideone上的实例 。

Answer 3

这很容易解决：停止通过引用获取值。 如果要确保参数可寻址 ，请将其设为地址 ：

void bar_const(const long *) { }

这样，用户必须传递指针。 并且您无法获得指向临时的指针（除非用户非常恶意）。

话虽如此，我认为你对这件事的看法是......错误的。 它归结为这一点。

也许我会接受它的地址，而不是意识到我实际上是在接受一个临时的地址。

取一个const&的地址，恰好是一个临时的，实际上很好。 问题是你不能长期存放它。 你也不能转让它的所有权。 毕竟，你有一个const引用。

这就是问题的一部分。 如果你拿一个const& ，你的界面会说，“我被允许使用这个对象，但我不拥有它，也不能将所有权归给别人。” 由于您不拥有该对象， 因此无法长期存储它。 这就是const&手段。

取一个const*代替可能会有问题。 为什么？ 因为你不知道那个指针来自哪里。 谁拥有这个指针？ const&有许多语法保护措施，以防止你做坏事（只要你不采取其地址）。 const*什么都没有; 你可以将指针复制到心脏的内容。 您的界面没有说明您是否被允许拥有该对象或将所有权转让给他人。

这种模糊性是C ++ 11具有unique_ptr和shared_ptr等智能指针的原因。 这些指针可以描述真实的内存所有权关系。

如果您的函数按值获取unique_ptr ，那么您现在拥有该对象。 如果它需要shared_ptr ，那么您现在共享该对象的所有权。 有确保所有权的语法保证（再次，除非你采取不愉快的步骤）。

如果您不使用C ++ 11，则应使用Boost智能指针来实现类似的效果。

Answer 4

你不能，即使你可以，它可能也没有多大帮助。 考虑：

void another(long const& l)
{
    bar_const(l);
}

即使你可以某种方式阻止绑定到临时作为bar_const输入，也可以使用绑定到临时的引用来调用像another函数，并且你最终会处于相同的情况。

如果你不能接受临时，你需要使用对非const或指针的引用：

void bar_const(long const* l);

需要左值来初始化它。 当然，功能就像

void another(long const& l)
{
    bar_const(&l);
}

仍会造成问题。 但是如果你全局采用约定来使用指针，如果对象的生命周期必须延伸到调用的结尾，那么希望another的作者会想到他为什么要获取地址，并避免它。

Answer 5

我认为你的int和long例子有点像一个红色的鲱鱼，因为在规范的C ++中，你永远不会通过const引用传递内置类型：你通过值或非const引用传递它们。

因此，我们假设您有一个大的用户定义类。 在这种情况下，如果它正在为您创建临时值，那么这意味着您为该类创建了隐式转换。 您所要做的就是将所有转换构造函数（可以使用单个参数调用的构造函数）标记为explicit ，编译器将阻止自动创建这些临时值。 例如：

class Foo
{
    explicit Foo(int bar) { }
};

Answer 6

（回答我自己的问题，感谢我对另一个问题的答案 。感谢@hvd。）

简而言之，将函数参数标记为volatile意味着它不能绑定到右值。 （任何人都可以为此确定一个标准的引用吗？Temporaries可以绑定到const& ，但不是const volatile &显然。这就是我对g ++ - 4.6.1的看法 。（额外：请参阅此扩展评论流以获取一些血腥细节那些方式在我头上:-)））

void foo( const volatile Input & input, Output & output) {
}

foo(input, output); // compiles. good
foo(get_input_as_value(), output); // compile failure, as desired.

但是 ，您实际上并不希望参数是volatile 。 所以我写了一个小包装器来const_cast the volatile 。 所以foo的签名改为：

void foo( const_lvalue<Input> input, Output & output) {
}

包装器在哪里：

template<typename T>
struct const_lvalue {
    const T * t;
    const_lvalue(const volatile T & t_) : t(const_cast<const T*>(&t_)) {}
    const T* operator-> () const { return t; }
};

这可以仅从左值创建

有任何缺点吗？ 这可能意味着我不小心误用了一个真正不稳定的物体，但在我的生命中，我从未使用过volatile 。 我认为这对我来说是正确的解决方案。

我希望默认情况下养成使用所有合适参数的习惯。

在ideone上演示