Question

在具有泛型类型T的C ++模板中，我可以使用

const T &

获取对常数T的引用。但是，如果现在T本身是引用类型（例如T = int＆amp;），则上述术语解析为

int &

而不是

const int &

这很有道理，因为任何引用本身都是不变的。但是，还有办法要求

const T &

如果T本身是参考类型？

编辑：要评估的示例代码（g ++编译器）：

template <typename T> class TemplateClass
{
public:
    void foo(const T &bar) { }
};

int main()
{
    TemplateClass<int &> x;
    x.foo(0);   // <-- compile error: no conversion from int to int&
    return 0;
}

Answer 1

删除引用：

template<typename T>
void Test(const typename std::remove_reference<T>::type & param)
{
        param = 20;
}

现在它按预期工作。

Answer 2

您始终可以使用模板专门化为任何类型的参考实现不同的版本：

template <typename T> struct X {
  void foo(T const&);
};

template <typename T> struct X<T&> {
  void foo(T const&);
};

现在，X<int>::foo预计int const&和X<int&>::foo也需要int const&。

然而，从你的问题中你并不完全清楚你要做什么。

编辑：如果没有以下

的模板专业化，我的g ++版本（4.6.1）就不会抱怨

int i = 7;
X<int&>(i);

虽然它适用于

X<int&>(7);

哪个是正确的IMO，因为您尝试将临时（7）转换为可变引用（即使这是对const引用的引用）。

编辑2：如果你想减少重复的代码，那么不要专门化你的原始类，但使用它：

template <typename T> struct R {
  typedef T& Ref;
  typedef T const& ConstRef;
};

template <typename T> struct R<T&> {
  typedef T& Ref;
  typedef T const& ConstRef;
};

template<typename T> struct X {
  void foo(typename R<T>::ConstRef x);
};

Answer 3

我遇到了同样的问题。好像是'＆amp;'类型转换运算符比'const'限定符绑定更强。所以当我们有这个代码时：

template<class t>
void fun(const t i)
{
}

fun<int&>();

函数以类型 void（int＆amp;）结束，而不是预期的 void（const int＆amp;）。

要解决此问题，我已定义此模板：

template<class t> struct constify { typedef t type; };
template<class t> struct constify<t&> { typedef const t& type; };

现在将您的功能定义为：

template<class t>
void fun(typename constify<t>::type i)
{
}

fun<int&>();

实例化的函数将根据需要具有 void（const int＆amp;）类型。

c ++模板中的const引用

3 个答案: