Question

class BI {
public:
   virtual void fun() = 0;
   virtual ~BI() {}
};

class B : public BI {
public:
   void fun() {}
};

template <typename T>
class A {
   T* obj;
public:
   void funT(const T*&) /* adding reference is creating error */;
};

template <typename T>
void A<T>::funT(const T*& obj) {
}

int main() {
   A<B> obj;
   obj.funT(new B());
}

用g ++编译器编译上面的代码时，我收到错误：没有匹配函数来调用A :: funT（B ）*。但是当我删除参考文献＆＃39; ＆amp; ＆＃39; funT（）声明中的运算符为void funT(const T* obj)，然后编译并正常工作。为什么不允许参考运算符？

Answer 1

您要求引用指针，您无法获得临时值的引用（除非它们是C ++ 11 rvalue引用）。

确保您已将左值作为参数传递，以使参考有效。

e.g。

#include <iostream>
using namespace std;

class BI {
public:
   virtual void fun() = 0;
   virtual ~BI() {}
};

class B : public BI {
public:
   void fun() {}
};

template <typename T>
class A {
   T* obj;
public:
   void funT(const T*&);
};

template <typename T>
void A<T>::funT(const T*& obj) {
}

int main() {
   A<B> obj;
   const B* ptr = new B(); // <--  This is an lvalue
   obj.funT(ptr);
   delete ptr; // Also clean it up after you used it
}

http://ideone.com/T4QJzi

Answer 2

这是一个更简单的程序，它表现出同样的问题：

void fun(const int*&) {}

int main() {
    int x;
    fun(&x);
}

它会产生以下错误：

invalid initialization of non-const reference of type ‘const int*&’
from an rvalue of type ‘int*’

这是有道理的。 fun接受类型为＃34的参数;引用非const 指向const int＆＃34;的指针，我们尝试将其传递给类型为临时的＆＃34;指向int＆＃34;的指针。对非const类型的引用不会与临时类型绑定，因为临时类通常是不可变的。在这种情况下，如果我们被允许将&x作为参数传递给fun，则fun将能够修改x的地址，而&的地址不会void fun(const int*) {}。没有任何意义。

正如您所注意到的，删除int会使代码格式正确：

int

现在我们只是传递一个指向fun的指针，其中指向const int的类型指针值，这是一个简单的隐式转换。

或者，您可能希望void fun(int* const&) {}采用类型＆＃34的参数;引用 const 指向int＆＃34;

void fun(const int* const&) {}

或者对const fun的const指针的引用：

{{1}}

但是对const指针的引用有点愚蠢，因为简单的指针也同样好。

最后，您可以保留原始声明{{1}}，并避免尝试传递临时参数作为其参数。

Answer 3

错误信息很清楚。参数类型是对T 指针的引用，但您要发送 指向T 的指针。在这种情况下，Temporaries不能作为引用传递。你可以写：

int main() {
 A<B> obj;
 const B* b=new B(); //create a lvalue
 obj.funT(b);
 delete b; // make sure to release memory.
}

具有指针引用模板参数的C ++模板成员函数

3 个答案: