어떻게 오버로딩과 오버라이드가 함께 작동합니까?

Question

오버로드 및 오버라이드의 기본 사항을 이해하지만 뭔가 혼란 스럽습니다. I는 간단한 예를 사용하여 설명하려고한다 :

• 클래스 B가
• 클래스 D는 X와 X보다 우선
• 클래스 D가 클래스 B를 계승 함수 X (B & B)을 가진다 (B & B) 또한 X로 과부하 (D & d).

  void test(D& d1, B& b1, D& d2, B& b2){ 
      d1.X(d2); 
      d1.X(b2); 
      b1.X(d2); 
      b1.X(b2); 
  } 
  
  int main(){ 
      D d1, d2, d3, d4; 
      test(d1, d2, d3, d4); 
  } 
  

  내가 test()의 세 번째와 네 개의 라인이 일반적인 메커니즘이있는 어떤 전화를 할 X()의 구현을 결정 얼마나 매우 확실하지 오전 :

나는 다음 코드를 사고.

Answer 1

과부하 선택 (X(B&) 대 X(D&))과 두 가지 단계가 있습니다. 일단 완료되면 선택한 기능의 올바른 구현을 찾습니다. 전자는 컴파일 시간에 발생하고 정적 유형의 객체 의 및 인수에 따라, 후자는 실행시 발생과 개체의 동적 유형에 따라 (가 이가에 의존하지 않습니다 인수의 동적 유형).자신의 정적 형식 있도록이 D&이며, d1 및 d2은 D&, 그리고 자신의 정적 유형 B& 그래서 b1 및 b2는 B&로 선언 다음과 같이

네 개의 개체가 선언됩니다. 정적 유형은 코드에서 선언 한 것입니다. 네 개의 참조가 실제로 당신이 main()에 D -objects으로 만든 개체를 참조하기 때문에 네 가지에 대한

그러나 동적 유형는 D입니다.

따라서, 첫 번째 단계는, 과부하 선택 : 정적 유형 B&이고 B 대한 클래스 정의는이 하나 개의 기능을 갖기 때문에 b1.X(b2) 및 b1.X(d2) 인 경우, 단지 하나의 가능한 과부하 X(B&)이있다. 그러나 d1.X(b2) 및 d1.X(d2)의 경우 정적 유형이 D&이므로 오버로드 선택은 D의 클래스 정의를 기반으로합니다. 따라서 두 가지 오버로드가 고려됩니다 (X(B&) 및 X(D&)). 인수 b2 인 경우, 이전의 과부하가 선택되고, 인수 d2 때, 후자 과부하 정적 (= 선언) 개체와 인수 유형에 기반 – 모두 선택된다.

두 번째 단계는 선택한 과부하의 올바른 구현을 선택하는 것입니다. 이것은 런타임에 발생하며 객체의 동적 유형 (인수가 아님)에 따라 다릅니다. 따라서 b1.X(b2)의 경우 동적 유형 b1은 D이므로 D::X(B&)을 호출하게됩니다. b1.X(d2)과 동일 : 이전 단계에서 선택한 과부하는 X(B&)이지만 선택한 구현은 D::X(B&)입니다. (D::X(D&)은 다른 오버로드가 될 것이고 이미 오버로드가 정적 유형을 기반으로 선택 되었기 때문에이 시점에서 후보가 아닙니다. 오브젝트의 동적 형태는 정지형 같기 때문에 d1.X(b2) 및 d1.X(d2)의 경우, 선택된 기능은, 첫 번째 단계, D::X(B&)D::X(D&)과 동일하다.

Answer 2

가상 함수 X을 B(B::X)에 선언하고 파생 클래스 D(D::X)의 X을 재정의합니다. B::X 및 D::X의 매개 변수 목록이 B::X 및 D::X가 다른 고려, 다른 경우 (가상 키워드로 선언하지 않는 한), D::X는 B::X을 무시하지 않으며, D::X 가상 없습니다. 대신 D::X은 B::X을 숨 깁니다.

#include <iostream> 
using namespace std; 

struct B { 
    virtual void X() { cout << "Class B" << endl; } 
}; 

struct D: B { 
    void X(int) { cout << "Class D" << endl; } 
}; 

int main() { 
    D d; 
    B* pb = &d; 
// d.X(); 
    pb->X(); 
} 

심지어 d.X()를 호출 할 수 없습니다, 그것은 D::X(int)으로 숨겨져 있습니다. 그러나 pb->X()은 문제가 없습니다. 따라서 귀하의 경우

:

이

struct B { 
    virtual void X(B& b) { cout << "Class B" << endl; } 
}; 

struct D: B { 
    void X(B& b) { cout << "Class D" << endl; } 
    void X(D& d) { cout << "Class D" << endl; } 
}; 

D::X가 B::X을 숨 깁니다. 그래서 d1.X(d2)과 d1.X(b2)은 test()과 아무 관계가 없습니다. B::X. b1.X(d2) 및 b1.X(b2)은 test()입니다. 전화 번호는 D::X입니다. B::X은 D에서 보이지 않지만 D::X(B&)을 가상 키워드와 함께 선언하는지 여부와 관계없이 D::X(B&)은 가상입니다. 컴파일러는 그것이 가상 함수라는 것을 알고 있으므로 D::X(B&)이 호출됩니다.

EDIT : B1.X (b2)에 대한 설명이 더 많습니다. B :: X는 가상 함수이고 D :: X는이를 무시하므로 확실히 동적 바인딩으로 D :: X를 호출합니다. 그리고 오버로딩은 컴파일 시간에 결정되므로 D :: X (D &)를 호출하지 않습니다.