如何訪問派生類中的受保護成員？

Question

從http://www.parashift.com/c++-faq-lite/basics-of-inheritance.html#faq-19.5

甲構件（無論數據成員或成員函數）中的一類受保護的節中聲明只能由成員函數和該類的朋友訪問，並且通過成員函數和派生類的朋友

那麼，在派生類中訪問受保護函數fun的方法是什麼？

#include <iostream> 
using namespace std; 

class X 
{ 
    private: 
     int var; 
    protected: 
     void fun() 
     { 
      var = 10; 
      cout << "\nFrom X" << var; 
     } 
}; 

class Y : public X 
{ 
    private: 
     int var; 
    public: 
     void fun() 
     { 
      var = 20; 
      cout << "\nFrom Y" << var; 
     } 

     void call() 
     { 
      fun(); 

      X objX; 
      objX.fun(); 
     } 
}; 

這導致：

anisha@linux-dopx:~/> g++ type.cpp 
type.cpp: In member function ‘void Y::call()’: 
type.cpp:9:8: error: ‘void X::fun()’ is protected 
type.cpp:32:14: error: within this context 

我看到了這一點：Accessing protected members in a derived class

考慮：

你只能訪問受保護的成員（或 你的類型的實例衍生從你的類型）。您無法訪問父代或表親類型的實例的受保護成員。

就你而言，Derived類只能訪問派生實例的b成員，而不是其他Base實例。

更改構造函數以獲取派生實例也將解決 的問題。

如何在不更改構造函數聲明的情況下實現這一點？

Answer 1

我認爲你正在做應該的東西看起來是這樣的：

#include <iostream> 
using namespace std; 

class X 
{ 
    private: 
     int var; 
protected: 
    virtual void fun() 
    { 
     var = 10; 
     cout << "\nFrom X" << var; 
    } 
}; 

class Y : public X 
{ 
private: 
    int var; 
public: 
    virtual void fun() 
    { 
     var = 20; 
     cout << "\nFrom Y" << var; 
    } 

    void call() 
    { 
     fun(); 


     X::fun(); 
    } 
}; 

這樣，你可以從你的基類中調用隱伏成員。否則，您必須添加朋友X，因爲它在其他帖子中被指出。

Answer 2

一種解決方案是增加friend class Y爲X.

Answer 3

在無效Ÿ::（）調用

X objX; 
    objX.fun(); 

//這裏你試圖訪問物objx的保護成員，this /電流對象Y不包含objX作爲基礎對象，它們都是不同的對象。這就是爲什麼你不能訪問其成員。

作爲@anycom所告知的解決方案，您可以將Y的朋友作爲X的朋友。

編輯：我的意思是，從內Y（從X繼承），你可以簡單地調用保護/的公共成員「它的」基類X即你訪問它的基礎件簡單。但是，這並不意味着您現在可以訪問類型爲X的所有對象的受保護成員，因爲您試圖訪問類X的外部作用域中的成員，即通過X的對象訪問這些成員。你知道所有這些規則，但它似乎你做了太多的思考0_o

Answer 4

你沒有訪問你的派生類中的保護函數，你試圖超載它，並從保護提升到公共。這是禁止的操作，您只能隱藏派生類中的函數，例如過載保護功能作爲私人使用。

訪問保護功能是指一類的一些成員稱之爲：

class Y : public X 
{ 
public: 
    void call() { 
     fun(); 
    } 
} 

或像你通過objX.fun();調用它也是正確的。

Answer 5

見這個例子：

#include <iostream> 
using namespace std; 

class X { 
    private: 
    int var; 
    protected: 
    void fun() 
    { 
     var = 10; 
     cout << "\nFrom X" << var; 
    } 
}; 

class Y : public X { 
    private: 
    int var; 
    public: 
    void fun() 
    { 
     var = 20; 
     cout << "\nFrom Y" << var; 
    } 

    void call() 
    { 
     fun(); /* call to Y::fun() */ 
     X::fun(); /* call to X::fun() */ 

     X objX; 
     /* this will not compile, because fun is protected in X   
     objX.fun(); */ 

    } 
}; 

int main(int argc, char ** argv) { 
    Y y; 
    y.call(); 
    return 0; 
} 

這就產生

 
From Y20 
From X10 

因爲你Y中重載fun() - 方法，你必須給編譯器的提示哪一個你的意思是，如果你想通過調用X::fun()來調用X中的fun -method。

Answer 6

好吧，如果friend是確定的，那麼這個角度也可以被確定：

#include <iostream> 

class X { 
private: 
    int var; 
protected: 
    virtual void fun() { 
     var = 10; 
     std::cout << "\nFrom X" << var; 
    } 

    static void Fun(X& x) { 
     x.fun(); 
    } 
}; 

class Y : public X { 
private: 
    int var; 
public: 
    virtual void fun() { 
     var = 20; 
     std::cout << "\nFrom Y" << var; 
    } 

    void call() { 
     fun(); 
     X objX; 
     objX.fun(); /* << ne-ne */ 
     Fun(objX); /* << ok */ 
    } 
}; 

當然，如果你使用這個銘記傳遞給X::Fun類型的原樣。