2

假设我有一个模板函数 foo(),它将两个整数引用作为参数。我希望模板函数也能自动处理常量引用(例如来自常量的引用)。这是一个通用的例子。我可以让 foo() 工作,但我必须为引用/常量引用参数的每个排列提供一个新的实现。

#include <iostream>

using namespace std;

template<typename A, typename B>
void foo(A& a, B& b)
{
    cout<<"a:"<<a<<" b:"<<b<<endl;
}

template<typename A, typename B>
void foo(A& a, const B& b)
{
    cout<<"a:"<<a<<" b:"<<b<<endl;
}

template<typename A, typename B>
void foo(const A& a, B& b)
{
    cout<<"a:"<<a<<" b:"<<b<<endl;
}

template<typename A, typename B>
void foo(const A& a, const B& b)
{
    cout<<"a:"<<a<<" b:"<<b<<endl;
}

int main()
{
    int x = 0;

    foo(x, x);
    foo(x, 10);
    foo(10, x);
    foo(20, 20);

    return 0;
}

上面的例子有点做作,但它是对我正在尝试做的事情的概括。在我更复杂的情况下,我有一个类作为一组参数的包装器。类构造函数是模板化的,如 foo(),可以有多达 10 个参数。枚举所有 2^10 个可能的构造函数将是一场噩梦。

4

3 回答 3

3

您描述的问题是完美转发问题。C++11 通过通用引用解决了这个问题:

template<typename A, typename B>
void foo(A&& a, B&& b) {
    bar(std::forward<A>(a), std::forward<B>(b));
}

这里的参数不是右值引用,而是通用引用。它们将具有与参数相同的 ref-ness 和 const-ness。

如果参数是右值,则 infoo参数将是带有名称的右值。命名的右值是左值。要将参数传递给具有保留值的子函数,您需要将它们包装在std::forward. 函数bar将获得ab完全相同的类型foo

于 2013-08-03T04:22:58.857 回答
1

如果模板不打算修改参数,那么只需提供带有的版本就可以了const&

template<typename A, typename B>
void foo(const A& a, const B& b)
{
    cout<<"a:"<<a<<" b:"<<b<<endl;
}

如果你传递一个非 const 左值,它仍然会被一个 const 引用绑定,一切都会正常工作。

如果您希望某些重载来修改参数,请重新考虑设计,因为它们看起来不像应该共享名称的函数。有一些例外,例如,访问结构内部成员的访问器,const&如果对象是,则您可能希望返回 a,否则返回const非常量引用......如果是这种情况,您可以采取相反的方式并提供只有非常量重载:

template<typename A, typename B>
void foo(A& a, B& b)

在这种情况下,如果参数是临时引用或非常量引用,则推导类型将反映它,并将参数与 a 绑定const&

int main() {
   int a = 5;
   const int b = 10;
   foo(a,b);          // foo<int,const int>(int&,const int&)
   foo(10,b);         // foo<const int,const int>(const int&, const int&)
}

重读您的问题,您似乎对完美转发感兴趣(这可能符合您的要求,也可能不符合您的要求)。如果是这种情况,并且如果您有 C++11 编译器,则可以将通用引用与可变参数模板一起使用。构建一个好的包装器是一件困难的事情,尽管您可能只能std::tuple用作实际的存储,这应该会使任务变得非常简单。

于 2013-08-03T02:27:49.133 回答
0

除了发布的所有正确答案之外,这里有一个简单的程序仅供您参考,因为这可能会帮助您更好地理解这个概念。

#include<iostream>
template<class X>
void func(X& x, X& y)
{
    //your code
}
template<class X, class Y>
void intermediateFunc(X&& x, Y&& y)
{
    func(x,y);
}

int main()
{
    int y = 9;
    intermediateFunc(5,5);
    intermediateFunc(y,5);
    intermediateFunc(5,y);
    intermediateFunc(y,y);
}
于 2013-08-03T07:42:42.463 回答