如何声明接受转发引用和 returns 引用或副本的函数模板

Question

我正在尝试声明一个函数模板，该模板在传递左值时应该接受和 return 非常量引用，但在传递右值时 return 应该接受 RVO 兼容的本地副本：

<template ?>
? StringReplace(? str, ? from, ? to);

我希望模板生成以下签名：

对于非常量左值

std::string& StringReplace(std::string& str, const std::string& from, const std::string& to);

对于 const 左值

std::string StringReplace(const std::string& str, const std::string& from, const std::string& to);

对于非常量右值

std::string StringReplace(std::string&&, const std::string&, const std::string&)

对于常量右值

std::string StringReplace(const std::string&&, const std::string&, const std::string&)

对于字符串文字

std::string StringReplace(std::string&&, const std::string&, const std::string&)

是否可以使用单一模板指定一个？也许标准库中有一个函数或方法可以通过使用一个或多个模板来实现相同的结果我应该作为参考吗？

请参阅了解我最终得到的版本。

Answer 1

我相信这个基本思路符合您的要求：

template<typename Str>
Str foo(Str&& str)
{
    return std::forward<Str>(str);
}

如果参数是 non-const 左值，则 Str 被减去 S& 并且转发也解析为 S&。

如果参数是右值，则 Str 被推导为 S，并且 return 值是来自参数的 copy/move-constructed。

如果您明确给出模板参数，那么转发引用推导将被抑制，如果函数参数是 S& 可以直接绑定到的左值，您必须确保给出 S& ;或者 S 否则。

通过引用传递的函数参数从不存在 RVO；例如假设调用上下文是 std::string s = StringReplace( std::string("foo"), x, Y); ，此时编译器无法知道为 s 使用相同的内存 space 作为临时字符串。您能做的最好的事情就是 move-construct return 值。

注意： 您的原始代码试图为所有 3 个参数推导 Str，这会导致推导冲突。您应该推断出转发引用，对于其他两个引用，请使用 non-deduced 上下文或不同的模板参数。例如：

template<typename Str, typename T>
Str StringReplace(Str&& str, T const& from, T const& to)

或使用超级答案中所示的CRef（如果参数出现在::的左侧，则推导被禁用）。

Answer 2

通过对参数和 return 值进行一些积极的塑造，这似乎几乎可以满足您的指定要求。

情况 2 需要用 <std::string&> 指定，否则转发引用将不起作用。

#include <iostream>
#include <type_traits>

template <typename T>
using CRef = typename std::remove_reference<T>::type const&;

template<typename Str>
Str StringReplace(Str&& str, CRef<Str> from, CRef<Str> to)
{
    std::cout << __PRETTY_FUNCTION__ << std::endl;

    if (std::is_same<std::string&&, decltype(str)>::value)
        std::cout << "rvalue-ref\n\n";
    else if (std::is_same<std::string&, decltype(str)>::value)
        std::cout << "lvalue-ref\n\n";

    return std::forward<Str>(str);
}

int main() {
    std::string s1;

    StringReplace(s1, "", "");

    // Forwarding reference will deduce Str to std::string& when passing an lvalue
    StringReplace<std::string&>(s1, "", "");

    StringReplace(std::move(s1), "", "");

    StringReplace<std::string>(std::move(s1), "", "");

    StringReplace<std::string>("", "", "");

    const std::string& test = s1;
    StringReplace(test, "", "");
}

如何处理const &被传入的问号。如你所见，如果你运行这个，它也会return一个const &现在的情况。

Live example

Answer 3

根据评论和答案，我最终得到了两个模板：

// true only if T is const
template<typename T>
using StringReplaceIsConst = std::conditional_t<std::is_const<std::remove_reference_t<T>>::value, std::true_type, std::false_type>;


// lvalue, lvalue reference, rvalue, rvalue reference, string literal
template<typename Str, typename = std::enable_if_t<!StringReplaceIsConst<Str>::value>>
Str StringReplace(
    Str&& str,
    const std::remove_reference_t<Str>& from,
    const std::remove_reference_t<Str>& to
) {
    return std::forward<Str>(str);
}

// const lvalue, const lvalue reference, const rvalue, const rvalue reference
template<typename Str, typename = std::enable_if_t<StringReplaceIsConst<Str>::value>>
std::decay_t<Str> StringReplace(
    Str&& str,
    const std::remove_reference_t<Str>& from,
    const std::remove_reference_t<Str>& to
) {
    std::decay_t<Str> mutableStr{std::forward<Str>(str)};
    StringReplace(mutableStr, from, to);
    return mutableStr;
}

Live example

虽然上面的版本有效，但我发现它不切实际。用户实际上感兴趣的是修改是就地还是复制:

更简单的调试：用户可以添加日志记录来验证调用了哪个版本
静态分析：用户可以注释定义，使编译器自动发出警告

考虑到这些要点：

// true only if T is a non-const lvalue reference
template<typename T>
using StringReplaceIsInPlace = std::conditional_t<std::is_lvalue_reference<T>::value && !std::is_const<std::remove_reference_t<T>>::value, std::true_type, std::false_type>;

// lvalue, lvalue reference, rvalue reference, 
template<typename Str, typename = std::enable_if_t<StringReplaceIsInPlace<Str>::value>>
Str StringReplace(
    Str&& str,
    const std::remove_reference_t<Str>& from,
    const std::remove_reference_t<Str>& to
) {
    return std::forward<Str>(str); // forward might be redundant, as Str is always an lvalue reference.
}

// const lvalue, const lvalue reference, rvalue, const rvalue, const rvalue reference, string literal
// std::decay ensures that return is by-value and compiler can use RVO
template<typename Str, typename = std::enable_if_t<!StringReplaceIsInPlace<Str>::value>>
std::decay_t<Str> StringReplace(
    Str&& str,
    const std::remove_reference_t<Str>& from,
    const std::remove_reference_t<Str>& to
) {
    std::decay_t<Str> mutableStr{std::forward<Str>(str)}; // move construct for non-const rvalues, otherwise copy-construct
    StringReplace(mutableStr, from, to);
    return mutableStr; // RVO-compatible
}

第二个声明可以使用 [[nodiscard]] (C++17)、[[gnu::warn_unused_result]]（clang 和 gcc）或 _Check_return_（msvs）注释。

Live example

如何声明接受转发引用和 returns 引用或副本的函数模板

How to declare a function template that accepts forwarding reference and returns either a reference or a copy

c++

c++14

perfect-forwarding