模板通过 const 引用传递

Question

我已经看过一些类似的问题，但我仍然很困惑。我试图弄清楚如何显式（不是通过编译器优化等）和 C++03 兼容来避免在将对象传递给专用模板时复制对象功能。这是我的测试代码：

#include <iostream>

using namespace std;

struct C
{
  C() { cout << "C()" << endl;  }
  C(const C&) { cout << "C(C)" << endl; }
  ~C() { cout << "~C()" << endl;  }
};

template<class T> void f(T) { cout << "f<T>" << endl; }

// This shows two possible ways, I don't need two overloads
// If I do it like (2) the function is not called, only if I do it like (1)

template<> void f(C c) { cout << "f<C>" << endl; } // (1)

template<> void f(const C& c) { cout << "f<C&>" << endl; } // (2)

int main()
{
    C c;
    f(c);
    return 0;
}

(1) 接受 C 类型的对象，并制作一个副本。这是输出：

C()
C(C)
f<C>
~C()
~C()

所以我尝试专门使用 const C& 参数 (2) 来避免这种情况，但这根本不起作用（显然原因在 这个问题）。

好吧，我可以“通过指针传递”，但这有点丑陋。那么有没有一些技巧可以很好地做到这一点呢？

编辑：哦，可能我不清楚。我已经有一个模板化函数

template<class T> void f(T) {...}

，但现在我想专门化这个函数来接受 const&到另一个对象：

template<> void f(const SpecificObject&) {...}

但只有当我将其定义为时才会调用它

template<> void f(SpecificObject) {...}

基本上我想要对这种专业化所做的是将 SpecificObject 适应模板接口，如

template<> void f(SpecificObject obj){ f(obj.Adapted()); } // call the templated version

EDIT2：好的，我可以强制 const C& 专门化以这种方式调用：

f<const C&>(c);

但是有没有办法让它像 f(c) 一样工作？

编辑3：如果有人最终会有类似的问题，我终于在另一个问题中找到了这个链接，它很有帮助： http://www.gotw.ca/publications/mill17.htm

Answer 1

您混淆了三个问题：模板、重载和参数传递。

只需删除特化并将参数作为 T const& 传递即可。

干杯&呵呵，

Answer 2

你为什么不超载：

void f(const C& c) { cout << "f(const C&)" << endl; }

Answer 3

这可行：

int main()
{
    C c;
    f<const C&>(c);
    return 0;
}

您的替代方案：

template<typename T> void f(const boost::reference_wrapper<T const>& c) 
    { cout << "f<boost_const_ref&>" << endl; } 

int main()
{
    C c;
    f(boost::cref(c));
    return 0;
}

实际上，您可以使用 boost::reference_wrapper 将引用传递到您想要使用它的位置。您可以使用 get() 来执行此操作，尽管 boost::reference_wrapper 具有隐式转换回引用的功能，因此您可能无需模板的部分专业化而只需传递 boost::cref(c ) 到常规的。

Answer 4

因此，如果您并不总是想接受 const 引用（这对于基本类型 [int、long、float 等] 是合理的），您可以使用一点 boost 魔法。

#include <iostream>
#include <boost/call_traits.hpp>

using namespace std;

struct C
{
  C() { cout << "C()" << endl;  }
  C(const C&) { cout << "C(C)" << endl; }
  //C& operator=(C const&) { cout << "C=C" << endl; return *this; }
  ~C() { cout << "~C()" << endl;  }
};

template<class T> void foo(typename boost::call_traits<T>::param_type inst) { cout << "f<T>" << endl; }
// specialization for calling class C
template<> void foo<C>(boost::call_traits<C>::param_type inst) { cout << "f<C>" << endl; }

int main()
{
  int i = 0;
  foo<int>(i);
  C c;
  foo<C>(c);
  return 0;
}

Answer 5

您的问题是实际参数 c 不是 const，因此主模板是更好的匹配，因为它不需要向类型添加“const”。如果您尝试按值传递和非常量引用传递函数，编译器会告诉您它无法解决该差异。

Answer 6

#include <iostream>

using namespace std;

struct C
{
  C() { cout << "C()" << endl;  }
  C(const C&) { cout << "C(C)" << endl; }
  ~C() { cout << "~C()" << endl;  }
};

template<class T> void f(const T&) { cout << "f<T>" << endl; }

int main()
{
    C c;
    f(c);
    return 0;
}

这确实可以实现您想要的功能，但是您必须对传递到函数中的所有值使用 const ref。我不知道这是否是您正在寻找的。