Question

有没有办法在C ++中编写一个接受左值和右值参数的函数，而不是将它作为模板？

例如，假设我编写了一个函数print_stream，它从istream读取并打印读取到屏幕上的数据，或者其他内容。

我认为像这样称呼print_stream是合理的：

fstream file{"filename"};
print_stream(file);

以及像这样：

print_stream(fstream{"filename"});

但是，如何声明print_stream以便两种用途都有效？

如果我将其声明为

void print_stream(istream& is);

然后第二次使用将无法编译，因为rvalue不会绑定到非const左值引用。

如果我将其声明为

void print_stream(istream&& is);

然后第一次使用将无法编译，因为左值不会绑定到右值引用。

如果我将其声明为

void print_stream(const istream& is);

然后函数的实现将无法编译，因为您无法从const istream读取。

我不能将该函数作为模板并使用“通用引用”，因为它的实现需要单独编译。

我可以提供两个重载：

void print_stream(istream& is);
void print_stream(istream&& is);

并且第二次调用第一次，但这似乎是很多不必要的样板，并且我发现每次用这样的语义编写函数时都必须这样做是非常不幸的。

我能做些什么更好的事情吗？

Answer 1

除了提供两个重载或让你的函数成为模板之外，没有太多的理智的选择，我想说。

如果你真的，真的需要一个（丑陋的）替代方案，那么我猜你唯一能做的事情就是让你的函数接受const&条件说你不能传递一个const - 限定类型的对象（你不想支持它）。然后，该函数将被允许抛弃引用的const。

但是我个人会写两个重载并根据另一个定义一个重载，所以你复制了声明，但不是定义：

void foo(X& x) 
{ 
    // Here goes the stuff... 
}

void foo(X&& x) { foo(x); }

Answer 2

另一个相当丑陋的选择是使函数成为模板并显式实例化两个版本：

template<typename T>
void print(T&&) { /* ... */ }

template void print<istream&>(istream&);
template void print<istream&&>(istream&&);

这可以单独编译。客户端代码只需要声明模板。

我个人只是坚持Andy Prowl的建议，但是。

Answer 3

大胆，拥抱通用转发功能并为其命名。

template<typename Stream>
auto stream_meh_to(Stream&& s) 
->decltype(std::forward<Stream>(s) << std::string{       }){
    return std::forward<Stream>(s) << std::string{"meh\n"};}

请注意，这将适用于任何有意义的工作，而不仅仅是ostream。这是一件好事。

如果使用无意义的参数调用函数，它将忽略此定义。顺便提一下，如果将缩进设置为4个空格，则效果会更好。：）

这与Cube的答案相同，不过我说的是，在可能的情况下，不检查特定类型并让通用编程做其事情更优雅。

Answer 4

// Because of universal reference
// template function with && can catch rvalue and lvalue 
// We can use std::is_same to restrict T must be istream
// it's an alternative choice, and i think is's better than two overload functions
template <typename T>
typename std::enable_if<
  std::is_same<typename std::decay<T>::type, istream>::value
>::type
print(T&& t) {
  // you can get the real value type by forward
  // std::forward<T>(t)
}

Answer 5

这里的解决方案可以扩展到任意数量的参数，并且不需要将accepting函数作为模板。

#include <utility>

template <typename Ref>
struct lvalue_or_rvalue {

    Ref &&ref;

    template <typename Arg>
    constexpr lvalue_or_rvalue(Arg &&arg) noexcept
        :   ref(std::move(arg))
    { }

    constexpr operator Ref& () const & noexcept { return ref; }
    constexpr operator Ref&& () const && noexcept { return std::move(ref); }
    constexpr Ref& operator*() const noexcept { return ref; }
    constexpr Ref* operator->() const noexcept { return &ref; }

};

#include <fstream>
#include <iostream>

using namespace std;

void print_stream(lvalue_or_rvalue<istream> is) {
    cout << is->rdbuf();
}

int main() {
    ifstream file("filename");
    print_stream(file); // call with lvalue
    print_stream(ifstream("filename")); // call with rvalue
    return 0;
}

与其他解决方案相比，我更喜欢这种解决方案，因为它是惯用的，它不需要每次使用时都编写功能模板，并且会产生明智的编译器错误，例如……

    print_stream("filename"); // oops! forgot to construct an ifstream

test.cpp: In instantiation of 'constexpr lvalue_or_rvalue<Ref>::lvalue_or_rvalue(Arg&&) [with Arg = const char (&)[9]; Ref = std::basic_istream<char>]':
test.cpp:33:25:   required from here
test.cpp:10:23: error: invalid initialization of reference of type 'std::basic_istream<char>&&' from expression of type 'std::remove_reference<const char (&)[9]>::type' {aka 'const char [9]'}
   10 |   : ref(std::move(arg))
      |                       ^

锦上添花的是，该解决方案还支持用户定义的转换构造函数和转换运算符的隐式应用……

#include <cmath>

struct IntWrapper {
    int value;
    constexpr IntWrapper(int value) noexcept : value(value) { }
};

struct DoubleWrapper {
    double value;
    constexpr DoubleWrapper(double value) noexcept : value(value) { }
};

struct LongWrapper {
    long value;
    constexpr LongWrapper(long value) noexcept : value(value) { }
    constexpr LongWrapper(const IntWrapper &iw) noexcept : value(iw.value) { }
    constexpr operator DoubleWrapper () const noexcept { return value; }
};

static void square(lvalue_or_rvalue<IntWrapper> iw) {
    iw->value *= iw->value;
}

static void cube(lvalue_or_rvalue<LongWrapper> lw) {
    lw->value *= lw->value * lw->value;
}

static void square_root(lvalue_or_rvalue<DoubleWrapper> dw) {
    dw->value = std::sqrt(dw->value);
}

void examples() {
    // implicit conversion from int to IntWrapper&& via constructor
    square(42);

    // implicit conversion from IntWrapper& to LongWrapper&& via constructor
    IntWrapper iw(42);
    cube(iw);

    // implicit conversion from IntWrapper&& to LongWrapper&& via constructor
    cube(IntWrapper(42));

    // implicit conversion from LongWrapper& to DoubleWrapper&& via operator
    LongWrapper lw(42);
    square_root(lw);

    // implicit conversion from LongWrapper&& to DoubleWrapper&& via operator
    square_root(LongWrapper(42));
}

Answer 6

如果我希望函数获取函数参数的所有权，则倾向于将参数作为值放置，然后将其移入。如果参数移动起来很昂贵（例如std ::：数组）。

一个典型的示例是设置对象的字符串成员：

class Foo {
   private:
      std::string name;
   public:
      void set_name( std::string new_name ) { name = std::move(new_name); }
};

有了这个函数的定义，我可以调用set名称，而没有字符串对象的副本：

Foo foo;
foo.set_name( std::string("John Doe") );
// or
std::string tmp_name("Jane Doe");
foo.set_name( std::move(tmp_name) );

但是如果我想保留原始值的所有权，我可以创建一个副本：

std::string name_to_keep("John Doe");
foo.set_name( name_to_keep );

最后一个版本的行为与传递const引用并进行副本分配非常相似：

class Foo {
   // ...
   public:
      void set_name( const std::string& new_name ) { name = new_name; }
};

这对于构造函数特别有用。

接受左值和右值参数的函数

6 个答案: