Question

在多重继承中，所有基类都包含具有不同功能的相同函数名称，我们可以使用“ ::”作用域解析运算符从特定基类访问受保护的函数。但是，我尝试了其他方法。我在子类内部创建了基类的对象。并尝试使用该特定类的直通对象调用该函数。但是我收到以下编译器错误： “‘void A :: func（int＆）”在此上下文中受到保护。” 请让我知道我在哪里出了错。

 #include <iostream>
using namespace std;
class A
{
    protected:
        void func(int & a)
        {
            a = a * 2;
        }
};

class B
{
  protected:
        void func(int & a)
        {
            a = a * 3;
        }
};

class C
{
  protected:
        void func(int & a)
        {
            a = a * 5;
        }
};

 class D : public A,public B,public C {
     public: 
     int a;
     A a_val;
     B b_val;
     C c_val;
     void update_val(int new_val)
    {
     a = new_val;
     a_val.func(a);
     b_val.func(a);
     c_val.func(a);
     }
   void check(int); 
};

void D::check(int new_val)
{
    update_val(new_val);
    cout << "Value = " << a << endl;
};

int main()
{
    D d;
    int new_val;
    cin >> new_val;
    d.check(new_val);
}

Answer 1

在派生类中时，它可以访问自己的祖先方法。但是它无权访问受成员保护的变量以及私有方法和变量。

重新设计代码，由于种种原因，您正在尝试尝试并扭曲其他类的设计。弗朗西斯（Francis）的代码是一个很好的解决方案，但是D不需要继承任何东西。

Answer 2

如果要将基类的代码保持为具有独立功能并且仍保持受保护状态，则解决此问题的最简单方法是稍微更改受保护函数的名称并添加一个调用受保护成员的公共函数：例如，请参见以下类声明：

class A {
public:
    void func( int& a ) {
        func_impl( a );
    }
protected:
    void func_impl( int& a ) {
        a = a * 2;
    }
};

class B {
public:
    void func( int& b ) {
        func_impl( b );
    }
protected:
    void func_impl( int& b ) {
        b = b * 3;
    }
};

class C {
public:
    void func( int& c ) {
        func_impl( c );
    }
protected:
    void func_impl( int& c ) {
        c = c * 5;
    }
};

class D : public A, public B, public C {
public:
    int a;
    A a_val;
    B b_val;
    C c_val;

    void update_val( int val ) {
        a = val;
        a_val.func( a );
        b_val.func( a );
        c_val.func( a );
    }

    void check( int );
};

void D::check( int val ) {
    update_val( val );
    std::cout << "Value = " << a << std::endl;
}

这提供了一个不错的公共接口来调用受保护的成员函数。这也解决了访问protected members的问题。当我运行您的程序并输入值5时，它将返回结果150并按预期工作。

此代码段应向您展示继承的工作原理以及何时可以访问受保护成员，以及何时不能访问受保护成员。

class DerivedA : public Base {
public:
    Base b;

    void call_message() {
        b.message(); // Protected Member of Base class can not be accessed
    }
};

class DerivedB : public Base {
public:
    void call_message() {
        message(); // This works without problem!
    }
};

就像我上面解决此问题的一种方法一样，是将一个公共接口调用方添加到受保护的实现中。

class Base {
public:
    void message() {
        message_impl();
    }
protected:
    void message_impl() {
        std::cout << "This is a protected member of Base\n";
    }
};

现在您可以执行以下操作：

class DerivedA {
public:
    Base b;

    void call_message() {
        b.message();      // Accessible through public interface.
    }
};

Answer 3

如果你不想创建另一个函数，你可以这样做：

@click="openmodal = 'modal1'"

这是可行的，因为 #include <iostream> using namespace std; class A { protected: void func(int & a) { a = a * 2; } }; class B { protected: void func(int & a) { a = a * 3; } }; class C { protected: void func(int & a) { a = a * 5; } }; class D : public A,public B,public C { public: int a; void update_val(int new_val) { a = new_val; this->A::func(a); this->B::func(a); this->C::func(a); } void check(int); }; void D::check(int new_val) { update_val(new_val); cout << "Value = " << a << endl; }; int main() { D d; int new_val; cin >> new_val; d.check(new_val); } 指的是 this 的当前实例，并且它已经继承了 class D、class A、class B。这样就可以直接访问各个类的受保护函数了。

请记住：如果您没有继承这些类，它将不起作用。

访问继承的函数

3 个答案: