根據繼承使用情況，以下哪項不允許？

Question

從here，

使用繼承，其下面的是不允許

一個）由子類改變父類的實現操作的

b）由所述亞類使用在父類實現操作

C）具有操作的子類

d）使用父類的屬性是子類，不EXIS噸父類

五）無

我不相信在上面的鏈接的答案，所以想在這裏澄清一下。請回答。

Answer 1

答案是e）無。

Answer 2

我會說答案是A.

您不能更改父類中操作的實現。

您可能可以覆蓋該實現（如果該操作聲明爲virtual），或者您可以隱藏原始實現......但從未實際更改從基類提供的實現。

考慮以下幾點：

class Parent 
{ 
    public: 
     virtual void sayHello() { count << "Hello World!"; } 
} 

class Child : Parent 
{ 
    public: 
     void sayHello() { cout << "42!"; } 
} 

現在看看結果：

// Will still say "Hello World!" because our child can never 
// change the parent's implementation 
Parent* parent1 = new Parent(); 
parent1->sayHello(); 

Answer 3

「A」 是答案，這裏的原因......

一個 - 父操作可以被覆蓋（在某種意義上被替換），但不能被改變。

#include <iostream> 

class A { 
public: 
    A() {} 
    virtual ~A() {} 
    virtual void foo() { 
     std::cout << "Hi, I'm A" << std::endl; 
    } 
}; 

class B : public A { 
public: 
    B() {} 
    virtual ~B() {} 
    virtual void foo() { 
     std::cout << "Hi, I'm B" << std::endl; 
    } 
}; 

int main() { 
    A* a = new B(); 
    a->foo(); 

    return 1; 
} 

上面的代碼將打印...

Hello, I'm B 

B :: foo的（）推翻了A :: foo的（），但並沒有改變它。

---

b - 是的，子類可以在父類中使用方法的實現。例如，如果我們將上述代碼中的B :: foo（）方法更改爲...

virtual void foo() { 
    A::foo(); // <--------------------------NOTE the addition of this call 
    std::cout << "Hi, I'm B" << std::endl; 
} 

...程序將打印...

Hi, I'm A 
Hi, I'm B 

---

c - 接收子類可以使用公共或保護父類的屬性，但不是私人屬性。例如：

#include <iostream> 

class A { 
public: 
    A() : pub(1), pro(2), pri(3) {} 
    virtual ~A() {} 
    virtual void foo() { 
     std::cout << "Hi, I'm A" << std::endl; 
    } 

    int pub; 

protected: 

    int pro; 

private: 

    int pri; 
}; 

class B : public A { 
public: 
    B() {} 
    virtual ~B() {} 
    virtual void foo() { 
     std::cout << pub << std::endl; 
     std::cout << pro << std::endl; 
     std::cout << pri << std::endl; // <----COMPILE ERROR 
    } 
}; 

int main() { 
    A* a = new B(); 
    a->foo(); 

    return 1; 
} 

由於子類B試圖訪問父類的私有成員，因此該代碼將在上面提到的行上出現編譯錯誤。如果另一個班級被宣佈爲朋友，但此規則有個例外，但您應該很少使用friend關鍵字。

---

d - 是的，一個子類可以有操作父類沒有的操作。例如：

#include <iostream> 

class A { 
public: 
    A() {} 
    virtual ~A() {} 
    virtual void foo() { 
     std::cout << "Hi, I'm A" << std::endl; 
    } 
}; 

class B : public A { 
public: 
    B() {} 
    virtual ~B() {} 
    virtual void foo() { 
     std::cout << "Hi, I'm B" << std::endl; 
    } 

    virtual void otherFunc() { 
     std::cout << "I'm a function that my parent class doesn't have." << std::endl; 
    } 
}; 

int main() { 
    B b; 
    A& a = b; 

    a.foo(); 
    a.otherFunc(); // <--- COMPILE ERROR 

    b.foo(); 
    b.otherFunc(); // <--- OK 

    return 1; 
} 

在上面的例子，otherFunc（）加入到子類B.試圖從一個參考調用它到A類會導致編譯錯誤。在B級上調用它可以按預期工作。

---

學習和了解肯定的最好方法是在編譯器中嘗試這些東西。試試上面的代碼。我在Visual Studio 2008中測試了它。沒有明確用COMPILE ERROR標記的例子應該可以工作。

Answer 4

我想說E.我想我會看到賈斯汀對於項目A所說的，但在他的例子中，繼承是一個紅色的鯡魚，我認爲他正在尋找一種不存在的技巧。

創建一個重寫行爲的孩子不會影響父母如果孩子沒有使用，但這似乎是不言而喻的。如果您更改了Parent的parent1實例來代替使用該孩子的構造函數，我認爲您會看到A點會得到肯定。

Answer 5

使用繼承，其下面的是不允許 一個）由子類

這是不允許的改變執行在父操作。您可以覆蓋虛函數，使得子類在通過指針或對基類的引用進行訪問時運行它們自己的這些函數的實現，但是不能阻止基類的實例運行其常規實現。 （從技術上講，如果基類定義了成員函數模板，你可以定義一個新的特化，它將從定義的角度到那個翻譯單元的末尾產生影響，但這是一個討厭的破解，而不是真正的內涵的模板）。

b）該子類

這使用實施父類的操作只允許公共/ protected成員 - 不是私有成員。

C）由子類

使用在父類屬性，這是隻允許公共/ protected成員 - 不是私有成員。

d）具有操作是子類，不父類

存在，這是明確允許的，也不可能限制。

因此，a）是最明確不允許的答案，而b）和c）可以在基類聲明中使用訪問說明符來允許或不允許使用。 d）絕對允許。