6

似乎无法访问模板策略类中的受保护成员，即使类层次结构似乎正确。

例如，使用以下代码片段：

#include <iostream>
using namespace std;

template <class T>
class A {
  protected:
    T value;
    T getValue() { return value; }
  public:
    A(T value) { this->value = value; }
};

template <class T, template <class U> class A>
class B : protected A<T> {
  public:
    B() : A<T>(0) { /* Fake value */ }
    void print(A<T>& input) {
      cout << input.getValue() << endl;
    }
};

int main(int argc, char *argv[]) {
  B<int, A> b;
  A<int> a(42);
  b.print(a);
}

编译器（在 OS X 上是 clang，但 gcc 返回相同类型的错误）返回以下错误：

Untitled.cpp:18:21: error: 'getValue' is a protected member of 'A<int>'
      cout << input.getValue() << endl;
                ^
Untitled.cpp:25:5: note: in instantiation of member function 'B<int, A>::print' requested here
  b.print(a);
    ^
Untitled.cpp:8:7: note: can only access this member on an object of type 'B<int, A>'
    T getValue() { return value; }
      ^
1 error generated.

奇怪的是，编译器的最后一条注释是完全正确的，但已经应用了，因为b对象是 type 'B<int, A>'。这是编译器错误还是代码有问题？

谢谢

4

4 回答 4

10

您误解了受保护访问的含义。

受保护的成员可由派生类调用。但仅限于类本身包含的基础对象。

例如，如果我简化问题，使用：

class A {
protected:
    void getValue(){}
};

class B : protected A
{
public:
    void print(A& input)
    {
        input.getValue(); //Invallid
    }
};

不能在类本身内部的“A”对象以外的“A”对象上调用 getValue。例如，这是有效的。

    void print()
    {
        getValue(); //Valid, calling the base class getValue()
    }

正如 Dan Nissenbaum 和 shakurov 所指出的那样。然而，这也是有效的：

void print(B& input)
{
    input.getValue();
}

这是因为我们明确地说输入是 B 的对象。编译器知道 B 的所有对象都具有对 getValue 的受保护访问。在我们传递 A& 的情况下，对象也可能是 C 类型，它可以从具有私有访问权限的 A 派生。

于 2013-03-29T11:46:14.980 回答
6

让我们暂时忘记模板，看看这个：

 class A {
   protected:
     int value;
     int getValue() { return value; }
   public:
     A(int value) { this->value = value; }
 };

 class B : protected A {
   public:
     B() : A(0) { /* Fake value */ }
     void print(A& input) {
       cout << input.getValue() << endl;
     }
 };

该print()方法的实现是错误的，因为您无法访问Ainside的非公共成员B。原因如下：从 内部B，您只能访问 的非公共成员B。这些成员可能是继承的，也可能不是——没关系。

另一方面，A& input可能不是对B. 它可能是对另一个子类的引用（很可能getValue()无法访问）。

于 2013-03-29T11:55:10.323 回答
2

不要被模板分心。它与错误无关。main编译器抱怨的行创建了一个类型的对象B<int, a>并尝试访问受保护的成员。无论类型如何，这都是不合法的。您只能在成员函数或友元函数内部使用受保护的成员。例如：

struct S {
protected:
    void f();
};

int main() {
    S s;
    s.f(); // error: attempts to call a protected member function
}
于 2013-03-29T11:40:48.483 回答
2

派生类的成员函数可以访问作为参数传递的其类型的任何对象内的受保护基类成员，只要作为参数传递的对象的显式声明类是派生类（或进一步派生类）。

作为基类类型显式传递的对象不能在派生类的成员函数中访问其受保护的成员。

换句话说，如果我们有：

class A
{
protected:
    int x;
}

class B : public A
{
    void foo(B b)
    {
        b.x; // allowed because 'b' is explicitly declared as an object of class B
    }
    void goo(A a)
    {
        a.x; // error because 'a' is explicitly declared as having *base* class type
    }
};

...然后该行a.x是不允许的，因为参数的显式类型是A，但受保护访问的规则仅适用于显式定义为与尝试访问该成员的类相同的类的对象。（...或派生自它的类；即，如果class C派生自B，则传递显式声明为类对象的对象C也x可以在B成员函数中访问。）

沙库罗夫在写作时给出了原因（释义）

A& 输入可能不是对 B 实例的引用。它可能是对另一个子类的引用（很可能 getValue() 不可访问）

这里也给出了这个答案的一个很好的解释：在另一个子类中访问一个基类的受保护成员。

有趣的是，我相信这来自这里的 C++ 标准：

11.4 受保护成员访问 [class.protected] 1 当非静态数据成员或非静态成员函数是其命名类 (11.2)115 的受保护成员时，将应用第 11 条中所述之外的附加访问检查早些时候，由于引用发生在某个类 C 的朋友或成员中，因此授予对受保护成员的访问权限。如果访问要形成指向成员的指针（5.3.1），则嵌套名称说明符应表示 C 或从 C 派生的类。所有其他访问都涉及（可能是隐式的）对象表达式（5.2.5）。在这种情况下，对象表达式的类应为 C 或从 C 派生的类。

于 2013-03-29T13:05:47.943 回答