명품 C++ 9장 가상 함수와 추상 클래스

예제 9-1 상속 관계에서 함수를 중복하는 경우 #include <iostream> using namespace std; class Base { public: void f() { cout << “Base::f() called” << endl; } }; class Derived : public Base { void f() { cout << “Derived::f() called” << endl; } void main() { Derived d, *pDer; pDer = &d; pDer->f(); // Derived::f() 호출 Base* pBase; pBase = pDer; // 업캐스팅 pBase->f(); // Base::f() 호출 } 객체 d pBase  void f() Base 멤버 Derived d; pDer  void f() Derived 멤버 함수 중복 객체 d pDer  void f() pDer->f(); void f() 실행 객체 d pBase  void f() 실행 pBase->f(); void f() Derived::f() called Base::f() called

가상 함수와 오버라이딩 가상 함수(virtual function) 함수 오버라이딩(function overriding) 동적 바인딩 지시어 컴파일러에게 함수에 대한 호출 바인딩을 실행 시간까지 미루도록 지시 함수 오버라이딩(function overriding) 파생 클래스에서 기본 클래스의 가상 함수와 동일한 이름의 함수 선 언 기본 클래스의 가상 함수의 존재감 상실시킴 파생 클래스에서 오버라이딩한 함수가 호출되도록 동적 바인딩 함수 재정의라고도 부름 다형성의 한 종류 class Base { public: virtual void f(); // f()는 가상 함수 };

오버라이딩 개념

오버로딩과 오버라이딩 사례 비교 오버로딩 오버라이딩 void f() class Base { public: void f() { cout << “Base::f() called” << endl; } }; class Derived : public Base { cout << “Derived::f() called” << endl; class Base { public: virtual void f() { cout << “Base::f() called” << endl; } }; class Derived : public Base { cout << “Derived::f() called” << endl; 가상 함수 오버라이딩 오버로딩 오버라이딩 Derived a; Derived b; 존재감 상실 void f() Base 멤버 void f() Base 멤버 void f() Derived 멤버 void f() Derived 멤버 객체 a 객체 b (a) a 객체에는 동등한 호출 기회를 가진 함수 f()가 두 개 존재 (b) b 객체에는 두 개의 함수 f()가 존재하지만, Base의 f()는 존재감을 잃고, 항상 Derived의 f()가 호출됨

예제 9–2 오버라이딩과 가상 함수 호출 void f() void f() void f() 존재감 상실 객체 d #include <iostream> using namespace std; class Base { public: virtual void f() { cout << "Base::f() called" << endl; } }; class Derived : public Base { virtual void f() { cout << "Derived::f() called" << endl; } int main() { Derived d, *pDer; pDer = &d; pDer->f(); // Derived::f() 호출 Base * pBase; pBase = pDer; // 업 캐스팅 pBase->f(); // 동적 바인딩 발생!! Derived::f() 실행 } pBase  void f() Base 멤버 Derived d; pDer 가상 함수 선언  void f() Derived 멤버 객체 d pDer  void f() pDer->f(); void f() 실행 객체 d pBase  void f() 동적바인딩 pBase->f(); void f() 실행 Derived::f() called

오버라이딩의 목적 –파생 클래스에서 구현할 함수 인터페이스 제공(파생 클래스의 다형성) 다형성의 실현 draw() 가상 함수를 가진 기본 클래스 Shape 오버라이딩을 통해 Circle, Rect, Line 클래스에서 자신만의 draw() 구현 class Shape { protected: virtual void draw() { } }; 가상 함수 선언. 파생 클래스에서 재정의할 함수에 대한 인터페이스 역할 class Circle : public Shape { protected: virtual void draw() { // Circle을 그린다. } }; class Rect : public Shape { protected: virtual void draw() { // Rect을 그린다. } }; class Line : public Shape { protected: virtual void draw() { // Line을 그린다. } }; 오버라이딩, 다형성 실현 void paint(Shape* p) { p->draw(); } paint(new Circle()); // Circle을 그린다. paint(new Rect()); // Rect을 그린다. paint(new Line()); // Line을 그린다. p가 가리키는 객체에 오버라이딩된 draw() 호출

동적 바인딩 동적 바인딩 파생 클래스에 대해 기본 클래스에 대한 포인터로 가상 함수를 호출하는 경우 객체 내에 오버라이딩한 파생 클래스의 함수를 찾아 실행 실행 중에 이루어짐 실행시간 바인딩, 런타임 바인딩, 늦은 바인딩으로 불림 동적바인딩 function1() virtual function2() ...... Base Base *p= &obj; p->function2(); 상속 실행 function2() ...... Derived obj

오버라이딩된 함수를 호출하는 동적 바인딩 void draw() #include <iostream> using namespace std; class Shape { public: void paint() { draw(); } virtual void draw() { cout << "Shape::draw() called" << endl; }; class Circle : public Shape { cout << "Circle::draw() called" << endl; int main() { Shape *pShape = new Circle(); // 업캐스팅 pShape->paint(); delete pShape; 기본 클래스에서 파생 클래스의 함수를 호출하게 되는 사례 #include <iostream> using namespace std; class Shape { public: void paint() { draw(); } virtual void draw() { cout << "Shape::draw() called" << endl; }; int main() { Shape *pShape = new Shape(); pShape->paint(); delete pShape; Shape::draw() called Circle::draw() called pShape = new Shape(); pShape->paint(); pShape = new Circle(); pShape->paint(); 동적바인딩 pShape  void paint() pShape Shape 멤버  void paint() Shape 멤버 void draw() void draw() new Shape() Circle 멤버 void draw() new Circle()

C++ 오버라이딩의 특징 오버라이딩의 성공 조건 오버라이딩 시 virtual 지시어 생략 가능 가상 함수의 접근 지정 가상 함수 이름, 매개 변수 타입과 개수, 리턴 타입이 모두 일치 오버라이딩 시 virtual 지시어 생략 가능 가상 함수의 virtual 지시어는 상속됨, 파생 클래스에서 virtual 생략 가능 가상 함수의 접근 지정 private, protected, public 중 자유롭게 지정 가능 class Base { public: virtual void fail(); virtual void success(); virtual void g(int); }; class Derived : public Base { virtual int fail(); // 오버라이딩 실패. 리턴 타입이 다름 virtual void success(); // 오버라이딩 성공 virtual void g(int, double); // 오버로딩 사례. 정상 컴파일 class Base { public: virtual void f(); }; class Derived : public Base { virtual void f(); // virtual void f()와 동일한 선언 생략 가능

예제 9-3 상속이 반복되는 경우 가상 함수 호출 Base, Derived, GrandDerived가 상속 관계에 있을 때, 다음 코드를 실행한 결과는 무엇인가? class Base { public: virtual void f() { cout << "Base::f() called" << endl; } }; class Derived : public Base { void f() { cout << "Derived::f() called" << endl; } class GrandDerived : public Derived { void f() { cout << "GrandDerived::f() called" << endl; } int main() { GrandDerived g; Base *bp; Derived *dp; GrandDerived *gp; bp = dp = gp = &g; bp->f(); dp->f(); gp->f(); } 동적 바인딩 bp->f(); Base 멤버 void f() dp->f(); Derived 멤버 void draw() void f() GrandDerived 멤버 gp->f(); void f() GrandDerived g; 동적 바인딩에 의해 모두 GrandDerived의 함수 f() 호출 GrandDerived::f() called

오버라이딩과 범위 지정 연산자(::) 범위 지정 연산자(::) 정적 바인딩 지시 기본클래스::가상함수() 형태로 기본 클래스의 가상 함수를 정적 바인딩으로 호출 Shape::draw(); class Shape { public: virtual void draw() { ... } }; class Circle : public Shape { Shape::draw(); // 기본 클래스의 draw()를 실행한다. .... // 기능을 추가한다.

예제 9-4 범위 지정 연산자(::)를 이용한 기본 클래스의 가상 함수 호출 #include <iostream> using namespace std; class Shape { public: virtual void draw() { cout << "--Shape--"; } }; class Circle : public Shape { Shape::draw(); // 기본 클래스의 draw() 호출 cout << "Circle" << endl; int main() { Circle circle; Shape * pShape = &circle; pShape->draw(); pShape->Shape::draw(); 정적바인딩 동적바인딩 정적바인딩 동적 바인딩을 포함하는 호출 --Shape--Circle --Shape--

가상 소멸자 가상 소멸자 소멸자를 virtual 키워드로 선언 소멸자 호출 시 동적 바인딩 발생     class Base { public: ~Base(); }; class Derived: public Base { ~Derived(); class Base { public: virtual ~Base(); }; class Derived: public Base { virtual ~Derived(); 동적 바인딩   파생 클래스의 소멸자가 자신의 코드 실행 후, 기본 클래스의 소멸자를 호출하도록 컴파일됨   ~Base() 소멸자만 실행 int main() { Base *p = new Derived(); delete p; } int main() { Base *p = new Derived(); delete p; }  ~Base() 소멸자 실행 ~Base() 소멸자 호출 ~Derived() 실행  ~Base() 실행 소멸자가 가상 함수가 아닌 경우 가상 소멸자 경우

예제 9-6 소멸자를 가상 함수로 선언 #include <iostream> using namespace std; class Base { public: virtual ~Base() { cout << "~Base()" << endl; } }; class Derived: public Base { virtual ~Derived() { cout << "~Derived()" << endl; } int main() { Derived *dp = new Derived(); Base *bp = new Derived(); delete dp; // Derived의 포인터로 소멸 delete bp; // Base의 포인터로 소멸 } ~Derived() ~Base() delete dp; delete bp;

오버로딩과 오버라이딩 비교

가상 함수와 오버라이딩 활용 사례 가상 함수를 가진 기본 클래스의 목적 가상 함수 오버라이딩 동적 바인딩 실행 기본 클래스의 포인터 활용

1. 가상 함수를 가진 기본 클래스의 목적 Shape은 상속을 위한 기본 클래스로의 역할 Shape.cpp Shape은 상속을 위한 기본 클래스로의 역할 가상 함수 draw()로 파생 클래스의 인터페이스를 보여줌 Shape 객체를 생성할 목적 아님 파생 클래스에서 draw() 재정의. 자신의 도형을 그리도록 유도 #include <iostream> #include "Shape.h" using namespace std; void Shape::paint() { draw(); } void Shape::draw() { cout << "--Shape--" << endl; Shape* Shape::add(Shape *p) { this->next = p; return p; Shape.h class Shape { Shape* next; protected: virtual void draw(); public: Shape() { next = NULL; } virtual ~Shape() { } void paint(); Shape* add(Shape* p); Shape* getNext() { return next;} }; Circle.h Rect.h Line.h class Circle : public Shape { protected: virtual void draw(); }; class Rect : public Shape { protected: virtual void draw(); }; class Line : public Shape { protected: virtual void draw(); }; #include <iostream> #include "Shape.h" #include "Circle.h" using namespace std; void Circle::draw() { cout << "Circle" << endl; } #include <iostream> #include "Shape.h" #include "Rect.h" using namespace std; void Rect::draw() { cout << "Rectangle" << endl; } #include <iostream> #include "Shape.h" #include "Line.h" using namespace std; void Line::draw() { cout << "Line" << endl; } Circle.cpp Rect.cpp Line.cpp

2. 가상 함수 오버라이딩 파생 클래스마다 다르게 구현하는 다형성 파생 클래스에서 가상 함수 draw()의 재정의 동적 바인딩에 의해 void Circle::draw() { cout << "Circle" << endl; } void Rect::draw() { cout << "Rectangle" << endl; } void Line::draw() { cout << "Line" << endl; }

3. 동적 바인딩 실행 : 파생 클래스의 가상 함수실행 #include <iostream> #include "Shape.h" #include "Circle.h" #include "Rect.h" #include "Line.h" using namespace std; int main() { Shape *pStart=NULL; Shape *pLast; pStart = new Circle(); // 처음에 원 도형을 생성한다. pLast = pStart; pLast = pLast->add(new Rect()); // 사각형 객체 생성 pLast = pLast->add(new Circle()); // 원 객체 생성 pLast = pLast->add(new Line()); // 선 객체 생성 // 현재 연결된 모든 도형을 화면에 그린다. Shape* p = pStart; while(p != NULL) { p->paint(); p = p->getNext(); } // 현재 연결된 모든 도형을 삭제한다. p = pStart; while(p != NULL) { Shape* q = p->getNext(); // 다음 도형 주소 기억 delete p; // 기본 클래스의 가상 소멸자 호출 p = q; // 다음 도형 주소를 p에 저장 } Circle Rectangle Line

main() 함수가 실행될 때 구성된 객체의 연결 pLast  p  pStart next next    next  next  next  .... .... .... .... .... void paint() void paint() void paint() void paint() void paint() void draw() void draw() void draw() void draw() void draw() void draw() void draw() void draw() void draw() Line 객체 void draw() Circle 객체 Circle 객체 Rect 객체 Rect 객체

4. 기본 클래스의 포인터 활용 기본 클래스의 포인터로 파생 클래스 접근 pStart, pLast, p의 타입이 Shape* p->paint()의 간단한 호출로 파생 객체에 오버라이딩된 draw() 함수 호출

순수 가상 함수 기본 클래스의 가상 함수 목적 순수 가상 함수 파생 클래스에서 재정의할 함수를 알려주는 역할 실행할 코드를 작성할 목적이 아님 기본 클래스의 가상 함수를 굳이 구현할 필요가 있을까? 순수 가상 함수 pure virtual function 함수의 코드가 없고 선언만 있는 가상 멤버 함수 선언 방법 멤버 함수의 원형=0;으로 선언 class Shape { public: virtual void draw()=0; // 순수 가상 함수 선언 };

추상 클래스 추상 클래스 : 최소한 하나의 순수 가상 함수를 가진 클래스 추상 클래스의 특징 추상 클래스 : 최소한 하나의 순수 가상 함수를 가진 클래스 추상 클래스의 특징 온전한 클래스가 아니므로 객체 생성 불가능 추상 클래스의 포인터는 선언 가능 class Shape { // Shape은 추상 클래스 Shape *next; public: void paint() { draw(); } virtual void draw() = 0; // 순수 가상 함수 }; void Shape::paint() { draw(); // 순수 가상 함수라도 호출은 할 수 있다. Shape shape; // 컴파일 오류 Shape *p = new Shape(); // 컴파일 오류 error C2259: 'Shape' : 추상 클래스를 인스턴스화할 수 없습니다. Shape *p;

추상 클래스의 목적 추상 클래스의 목적 추상 클래스의 인스턴스를 생성할 목적 아님 상속에서 기본 클래스의 역할을 하기 위함 순수 가상 함수를 통해 파생 클래스에서 구현할 함수의 형태(원형)을 보여주는 인터페이스 역할 추상 클래스의 모든 멤버 함수를 순수 가상 함수로 선언할 필요 없음

추상 클래스의 상속과 구현 추상 클래스의 상속 추상 클래스의 구현 추상 클래스를 단순 상속하면 자동 추상 클래스 추상 클래스를 상속받아 순수 가상 함수를 오버라이딩 파생 클래스는 추상 클래스가 아님 Shape은 추상 클래스 class Shape { public: virtual void draw() = 0; }; class Circle : public Shape { string toString() { return “Circle 객체”; } Shape shape; // 객체 생성 오류 Circle waffle; // 객체 생성 오류 class Shape { public: virtual void draw() = 0; }; class Circle : public Shape { virtual void draw() { cout << “Circle”; } string toString() { return “Circle 객체”; } Shape shape; // 객체 생성 오류 Circle waffle; // 정상적인 객체 생성 Shape은 추상 클래스 Circle도 추상 클래스 Circle은 추상 클래스 아님 순수 가상 함수 오버라이딩 추상 클래스의 단순 상속 추상 클래스의 구현

Shape을 추상 클래스로 수정 Shape.cpp #include <iostream> #include "Shape.h" using namespace std; void Shape::paint() { draw(); } void Shape::draw() { cout << “--Shape--" << endl; Shape* Shape::add(Shape *p) { this->next = p; return p; Shape.h class Shape { Shape* next; protected: virtual void draw() = 0; public: Shape() { next = NULL; } virtual ~Shape() { } void paint(); Shape* add(Shape* p); Shape* getNext() { return next;} }; Shape은 추상 클래스 Circle.h Rect.h Line.h class Circle : public Shape { protected: virtual void draw(); }; class Rect : public Shape { protected: virtual void draw(); }; class Line : public Shape { protected: virtual void draw(); }; #include <iostream> using namespace std; #include "Shape.h" #include "Circle.h" void Circle::draw() { cout << "Circle" << endl; } #include <iostream> using namespace std; #include "Shape.h" #include "Rect.h" void Rect::draw() { cout << "Rectangle" << endl; } #include <iostream> using namespace std; #include "Shape.h" #include "Line.h“ void Line::draw() { cout << "Line" << endl; } Circle.cpp Rect.cpp Line.cpp

예제 9-6(실습) 추상 클래스 구현 연습 다음 추상 클래스 Calculator를 상속받아 GoodCalc 클래스를 구현하라. class Calculator { public: virtual int add(int a, int b) = 0; // 두 정수의 합 리턴 virtual int subtract(int a, int b) = 0; // 두 정수의 차 리턴 virtual double average(int a [], int size) = 0; // 배열 a의 평균 리턴. size는 배열의 크기 }; #include <iostream> using namespace std; // 이 곳에 Calculator 클래스 코드 필요 class GoodCalc : public Calculator { public: int add(int a, int b) { return a + b; } int subtract(int a, int b) { return a - b; } double average(int a [], int size) { double sum = 0; for(int i=0; i<size; i++) sum += a[i]; return sum/size; } }; 순수 가상 함수 구현 int main() { int a[] = {1,2,3,4,5}; Calculator *p = new GoodCalc(); cout << p->add(2, 3) << endl; cout << p->subtract(2, 3) << endl; cout << p->average(a, 5) << endl; delete p; } 5 -1 3

예제 9-7(실습) 추상 클래스를 상속받는 파생 클래스 구현 연습 #include <iostream> using namespace std; class Calculator { void input() { cout << "정수 2 개를 입력하세요>> "; cin >> a >> b; } protected: int a, b; virtual int calc(int a, int b) = 0; // 두 정수의 합 리턴 public: void run() { input(); cout << "계산된 값은 " << calc(a, b) << endl; }; int main() { Adder adder; Subtractor subtractor; adder.run(); subtractor.run(); 다음 코드와 실행 결과를 참고하여 추상 클래스 Calculator를 상속받는 Adder와 Subractor 클래스를 구현하라. adder.run()에 의한 실행 결과 정수 2 개를 입력하세요>> 5 3 계산된 값은 8 계산된 값은 2 subtractor.run()에 의한 실행 결과

예제 9-7 정답 class Adder : public Calculator { protected: int calc(int a, int b) { // 순수 가상 함수 구현 return a + b; } }; class Subtractor : public Calculator { return a - b;