从接口派生的模板 - 多态性停止工作

Template derived from interface - polymorphism stopped working?

本文关键字：多态性 停止工作 接口 派生      更新时间：2023-10-16

可能的重复项：
访问派生类中的受保护成员

如果我有一个抽象基类和一个派生自它的具体模板化类，它有一个使用指向基类的指针的方法 - 似乎派生类不再将自己视为派生自它：

class AbstractBase
{
protected:
    virtual void test() = 0;
};
template < class T >
class Derived : public AbstractBase
{
public:
    virtual void call( AbstractBase* d ) { d->test(); }  //  Error!
protected:
    virtual void test() {}
};
int main()
{
    Derived< int > a;
    Derived< int > b;
    b.call( &a );
    return EXIT_SUCCESS;
}

此错误显示：

'Virtual void AbstractBase：：test（）' 受到保护

编译器没有错，肯定是protected的——但如果Derived< T >继承自AbstractBase，为什么要抱怨呢？

不允许这样做的原因是AbstractBase作为一种类型声明test受到保护。这使得它对所有人都是私有的，除非当前类是AbstractBase的直系后代。即便如此，该类只能通过同一类的对象访问成员，而不是不同的后代，也不能直接从AbstractBase本身访问成员。

template < class T >
class Derived : public AbstractBase
{
public:
    virtual void call( Derived * d ) {
        d->test(); // ok, d has same type as this
        AbstractBase *b = this;
        b->test(); // not ok
    }
protected:
    virtual void test() {}
};

如上所述，您可以只允许它用于相同类型的指针。或者，您可以为Derived创建一个代理基类，以实现调用test的virtual方法。这将允许从不同的Derived类型进行访问。

class DerivedBase : public virtual AbstractBase
{
public:
    virtual void call( DerivedBase * d ) { d->test(); }
};
template < class T >
class Derived : public DerivedBase
{
protected:
    virtual void test() {}
};

并且可以通过以下方式访问：

   Derived< int > a;
   Derived< int > b;
   Derived< float > c;
   b.call( &a );
   c.call( &a );

这与模板无关，但与一般受保护的成员访问有关。请参阅最新的公开C++标准草案的第 11.4 节受保护的成员访问 [class.protected]

超出第 11 条前面描述的额外访问检查 在非静态数据成员或非静态成员函数时应用 是其命名类的受保护成员 （11.2） 115 如前所述 以前，授予对受保护成员的访问权限，因为引用 发生在某个 C 类的朋友或成员中。如果访问是要形成 指向成员 （5.3.1） 的指针，嵌套名称说明符应表示 C 或派生自 C 的类。所有其他访问都涉及（可能 隐式）对象表达式 （5.2.5）。在这种情况下，类 对象表达式应为 C 或从 C 派生的类。

[示例：

class B {
protected:
    int i;
    static int j;
};
class D1 : public B {
};
class D2 : public B {
    friend void fr(B*,D1*,D2*);
    void mem(B*,D1*);
};
void fr(B* pb, D1* p1, D2* p2) {
   pb->i = 1; // ill-formed
   p1->i = 2; // ill-formed
   p2->i = 3; // OK (access through a D2)
   p2->B::i = 4; // OK (access through a D2, even though
                 // naming class is B)
   int B::* pmi_B = &B::i; // ill-formed
   int B::* pmi_B2 = &D2::i; // OK (type of &D2::i is int B::*)
   B::j = 5; // OK (because refers to static member)
   D2::j = 6; // OK (because refers to static member)
}
相关文章：