🐢 chap9. 추상화와 C++의 OPP

⭐ 9.1 추상화

• OOP에서의 추상화 : 추상 자료형을 다루는 것, 클래스 기반의 객체지향에서 추상 자료형은 추상 클래스를 다루는 것입니다.
• 추상 클래스 : 객체를 생성하고 나서, 사용하기에는 아직 준비되지도 완료되지도 않은 상태.

• 문장의 명사가 클래스라고 보고, 클래스 간에는 다음과 같은 관계가 성립할 수 있습니다.

  • 인간은 사과를 먹는다.
  • 인간은 오렌지를 먹는다.
  • 인간은 과일을 먹는다.
  • 이때 과일은 사과와 오렌지를 포함하는 부모 추상 클래스입니다. 그리고 사과와 오렌지는 구상 자료형이라고 합니다.
  • 과일을 더 추상적으로 만들어 인간은 소화 가능 한 것을 먹는다.
  • 소화 가능한 것은 과일보다 부모 추상 클래스입니다.
• 과도한 추상화 : 필요한 수준보다 더 추상적인 추상 자료형, 필요한 사항보다 더 추상 자료형을 생성하는 것.
• 추상화 원칙 : 프로그램의 중요한 각 기능은 소스 코드의 오직 한 부분에서만 구현되어야 한다. 비슷한 기능을 별개의 코드에서 수행할 때는 일반적으로 다양한 부분을 추상화해 하나로 결합하는 편이 좋다.

• 프로그래밍 언어에서 상속과 다형성은 추상화를 위해 필요합니다.

• 상속은 소화가능한 것과 같은 추상 클래스는 사과 등의 소화 가능한 것 관련 구상 클래스에 대한 부모타입이며 상속에 의해 이루어 집니다.

• 다형성 역시 중요한 역할을 합니다. 추상 자료형에는 해당 추상화 수준에서 기본 구현을 갖지 못하는 행위가 있습니다. 예시로 먹을 수 있는것(Eatable) 클래스에서 eatable_get_taste와 같은 행위 함수를 사용해 구현된 속성으로서의 맛은 (taste)은 먹을 수 있는 것 (Eatable) 객체를 다룰 때 정확한 값을 가질 수 없습니다. → 먹을 수 있는 것에는 맛에 대한 속성을 정의 할 수 없습니다. 다형성으로서 풀어낸다.

• 자식 클래스가 충분히 구체적일 때만 정의할 수 있습니다. 사과 객체는 맛에 대해 단맛을 반환할 수 있습니다. 다형성은 바로 이 지점 에서 도움이 됩니다.

• 자식 클래스가 오버라이딩할 수 있는 행위 함수를 가상 함수라고 불렀습니다. 가상 함수는 정의가 아예 없을 수도 있습니다. 가상 함수는 소유자 클래스를 추상화 합니다.

• 특정 수준에서 더욱 추상화해서, 속성과 기본 정의를 갖지 않는 가상 함수만을 포함하는 클래스까지 도달했습니다. 이러한 클래스를 인터페이스라고 합니다. 즉 인터페이스는 기능은 노출하지만 구현은 전혀 노출하지 않으며, 일반적으로 소프트웨어 프로젝트에서 다양한 컴포넌트 사이의 의존성을 만드는데 사용합니다. 예시로 먹는 자(Eater)와 먹을 수 있는 것(Eatable)클래스가 인터페이스입니다.

typedef enum {SWEET, SOUR} taste_t;

//함수 포인터 자료형
typedef taste_t (*get_taste_func_t)(void*);

typedef struct {
	// 가상 함수에 대한 정의를 가리키는 포인터
	get_taste_func_t get_taste_func;
} eatable_t;

eatable_t* eatable_new() {...} // 할당자 함수
void eatable_ctor(eatable_t* eatable){
	// 가상 함수에 대한 기본 정의는 없습니다.
	eatable->get_taste_func = NULL;
}

// 가상 행위 함수
taste_t eatable_get_taste(eatable_t* eatable){
	return eatable->get_taste_func(eatable);
}

• 인터페이스에 대한 정의와 설계 관점에서 이해할 수 있는 이유 외에는 기본적으로 먹을 수 있는 것(Eatable) 인터페이스에서 객체를 생성해서는 안 됩니다. 먹을 수 있는 것(Eatable) 인터페이스에서 객체를 생성하는 것이 C의 관점에서 가능하지만 충돌이 발생합니다. 절대 해서는 안됩니다.

eatable_t *eatable = eatable_new();
eatable_ctor(eatable);
taste_t taste = eatable_get_taste(eatable); // 세그멘테이션 오류
taste_t taste = eatable_get_taste((eatable_t)orange); //

free(eatable);

• 추상 자료형으로 객체를 생성하지 않으려면 클래스의 공용 인터페이스에서 할당자 함수를 제거합니다. 8장의 접근법을 기억한다면, 할당자 함수를 제거함으로써 오직 자식 클래스만이 부모의 속성 구조체로부터 객체를 생성할 수 있습니다.

• 외부 코드가 더 이상 부모의 속성 구조체로부터 객체를 생성할 수 없습니다. 예를 들어, eatable_t로부터 객체를 생성하지 못하게 하려고 합니다. 속성 구조체를 선언 앞에 두어 불완전 자료형으로 만들고, 공용 메모리 할당자인 eatable_new를 클래스에서 제거해야 합니다.

• 매우 높은 추상화 수준에서는 모든 함수 포인터가 NULL인 인터페이스를 갖습니다. 추상 자료형으로부터 외부 코드가 객체를 생성하지 못하게 하려면 공용 인터페이스에서 할당자 함수를 제거해야 합니다.

⭐ 9.2 C++의 객체지향 구성물

☑️ 9.2.1 캡슐화

• OPP 기법을 사용한 C와 OPP개념으로 구현한 C++ 두 프로그램에 대해 생성된 어셈블리 명령어를 비교하겠습니다.

#include <stdio.h>

typedef struct {
	int width;
	int length;
} rect_t;

int rect_area(rect_t* rect) {
	return rect->width * rect->length;
}

int main(int argc, char**argv){
	rect_t r;
	r.width = 10;
	r.length = 25;
	int area = rect_area(&r);
	printf("Area: %d\n", area);
	return 0;
}

#include <iostream>

class Rect{
public:
	int Area() {
		return width * length;
	}
	int width;
	int length;
};

int main(int argc, char** argv){
	Rect r;
	r.width = 10;
	r.length = 25;
	int area = r.Area();
	std::cout << "Area: " << area << std::endl;
	return 0;
}

gcc -S ExtremeC_examples_chapter9_1.c -o ex9_1_c.s
g++ -S ExtremeC_exampes_chapter9_1.cpp -o ex9_1_cpp.s

• C와 C++ 어셈블리 코드 비교

ubuntu@DESKTOP-FFH31MN:~/Extreme-C/ch09-abstraction-and-oop-in-c++$ cat ex9_1_c.s
        .file   "ExtremeC_examples_chapter9_1.c"
        .text
        .globl  rect_area
        .type   rect_area, @function
rect_area:
.LFB0:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movq    %rdi, -8(%rbp)
        movq    -8(%rbp), %rax
        movl    (%rax), %edx
        movq    -8(%rbp), %rax
        movl    4(%rax), %eax
        imull   %edx, %eax
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE0:
        .size   rect_area, .-rect_area
        .section        .rodata
.LC0:
        .string "Area: %d\n"
        .text
        .globl  main
        .type   main, @function
main:
.LFB1:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $48, %rsp
        movl    %edi, -36(%rbp)
        movq    %rsi, -48(%rbp)
        movq    %fs:40, %rax
        movq    %rax, -8(%rbp)
        xorl    %eax, %eax
        movl    $10, -16(%rbp)
        movl    $25, -12(%rbp)
        leaq    -16(%rbp), %rax
        movq    %rax, %rdi
        call    rect_area
        movl    %eax, -20(%rbp)
        movl    -20(%rbp), %eax
        movl    %eax, %esi
        leaq    .LC0(%rip), %rax
        movq    %rax, %rdi
        movl    $0, %eax
        call    printf@PLT
        movl    $0, %eax
        movq    -8(%rbp), %rdx
        subq    %fs:40, %rdx
        je      .L5
        call    __stack_chk_fail@PLT
.L5:
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1:
        .size   main, .-main
        .ident  "GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0"
        .section        .note.GNU-stack,"",@progbits
        .section        .note.gnu.property,"a"
        .align 8
        .long   1f - 0f
        .long   4f - 1f
        .long   5
0:
        .string "GNU"
1:
        .align 8
        .long   0xc0000002
        .long   3f - 2f
2:
        .long   0x3
3:
        .align 8
4:

4:

ubuntu@DESKTOP-FFH31MN:~/Extreme-C/ch09-abstraction-and-oop-in-c++$ cat ex9_1_cpp.s
        .file   "ExtremeC_examples_chapter9_1.cpp"
        .text
        .local  _ZStL8__ioinit
        .comm   _ZStL8__ioinit,1,1
        .section        .text._ZN4Rect4AreaEv,"axG",@progbits,_ZN4Rect4AreaEv,comdat
        .align 2
        .weak   _ZN4Rect4AreaEv
        .type   _ZN4Rect4AreaEv, @function
_ZN4Rect4AreaEv:
.LFB1731:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movq    %rdi, -8(%rbp)
        movq    -8(%rbp), %rax
        movl    (%rax), %edx
        movq    -8(%rbp), %rax
        movl    4(%rax), %eax
        imull   %edx, %eax
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1731:
        .size   _ZN4Rect4AreaEv, .-_ZN4Rect4AreaEv
        .section        .rodata
.LC0:
        .string "Area: "
        .text
        .globl  main
        .type   main, @function
main:
.LFB1732:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $48, %rsp
        movl    %edi, -36(%rbp)
        movq    %rsi, -48(%rbp)
        movq    %fs:40, %rax
        movq    %rax, -8(%rbp)
        xorl    %eax, %eax
        movl    $10, -16(%rbp)
        movl    $25, -12(%rbp)
        leaq    -16(%rbp), %rax
        movq    %rax, %rdi
        call    _ZN4Rect4AreaEv
        movl    %eax, -20(%rbp)
        leaq    .LC0(%rip), %rax
        movq    %rax, %rsi
        leaq    _ZSt4cout(%rip), %rax
        movq    %rax, %rdi
        call    _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@PLT
        movq    %rax, %rdx
        movl    -20(%rbp), %eax
        movl    %eax, %esi
        movq    %rdx, %rdi
        call    _ZNSolsEi@PLT
        movq    _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_@GOTPCREL(%rip), %rdx
        movq    %rdx, %rsi
        movq    %rax, %rdi
        call    _ZNSolsEPFRSoS_E@PLT
        movl    $0, %eax
        movq    -8(%rbp), %rdx
        subq    %fs:40, %rdx
        je      .L5
        call    __stack_chk_fail@PLT
.L5:
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1732:
        .size   main, .-main
        .type   _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB2235:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $16, %rsp
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        cmpl    $1, -4(%rbp)
        jne     .L8
        cmpl    $65535, -8(%rbp)
        jne     .L8
        leaq    _ZStL8__ioinit(%rip), %rax
        movq    %rax, %rdi
        call    _ZNSt8ios_base4InitC1Ev@PLT
        leaq    __dso_handle(%rip), %rax
        movq    %rax, %rdx
        leaq    _ZStL8__ioinit(%rip), %rax
        movq    %rax, %rsi
        movq    _ZNSt8ios_base4InitD1Ev@GOTPCREL(%rip), %rax
        movq    %rax, %rdi
        call    __cxa_atexit@PLT
.L8:
        nop
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE2235:
        .size   _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
        .type   _GLOBAL__sub_I_main, @function
_GLOBAL__sub_I_main:
.LFB2236:
        .cfi_startproc
        endbr64
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    $65535, %esi
        movl    $1, %edi
        call    _Z41__static_initialization_and_destruction_0ii
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE2236:
        .size   _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main
        .section        .init_array,"aw"
        .align 8
        .quad   _GLOBAL__sub_I_main
        .hidden __dso_handle
        .ident  "GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0"
        .section        .note.GNU-stack,"",@progbits
        .section        .note.gnu.property,"a"
        .align 8
        .long   1f - 0f
        .long   4f - 1f
        .long   5
0:
        .string "GNU"
1:
        .align 8
        .long   0xc0000002
        .long   3f - 2f
2:
        .long   0x3
3:
        .align 8

☑️ 9.2.2 상속

• 상속
  • 첫 번째 접근법
    • 자식 클래스의 포인터는 부모 클래스의 포인터로 할당할 수 있음
    • 자식 클래스는 부모 클래스의 비공개 정의에 접근할 수 있음
    • 자식의 속성 구조체 안에 구조체 변수를 둔다 ⇒ 단일 상속
  • 두 번째 접근법
    • 부모의 속성 구조체의 불완전 자료형으로부터 구조체 포인터를 둠
    • 부모 클래스의 비공개 구현에 의존하지 않음 ⇒ 다중 상속 (C++ 가능)

• C 과 C++ 버전의 상속 차이점

  • C 언어

  // File name: ExtremeC_examples_chapter9_2.c
  // Description: Inheritance in C
  
  #include <string.h>
  
  typedef struct {
    char c;
    char d;
  } a_t;
  
  typedef struct {
    a_t parent;
    char str[5];
  } b_t;
  
  int main(int argc, char** argv) {
    b_t b;
    b.parent.c = 'A';
    b.parent.d = 'B';
    strcpy(b.str, "1234");
    // We need to set a break point at this line.
    return 0;
  }
  

  • C++

  // File name: ExtremeC_examples_chapter9_2.cpp
  // Description: Inheritance in C++
  
  #include <string.h>
  
  class A {
  public:
    char c; // A
    char d; // B
  };
  
  class B : public A {
  public:
    char str[5];
  };   // 1234
  
  int main(int argc, char** argv) {
    B b;
    b.c = 'A';
    b.d = 'B';
    strcpy(b.str, "1234");
    // We need to set a break point at this line.
    return 0;
  }
  

  gcc -g ExtremeC_examples_chapter9_2.c -o ex9_2_c.out
  gdb ./ex9_2_c.out
  

  g++ -g ExtremeC_examples_chapter9_2.cpp -o ex9_2_cpp.out
  gdb ./ex9_2_cpp.out
  

  • C++ 에서 행위 함수와 속성을 클래스 안에 함께 두었다고 헷갈리면 안됨 (근데 이 예제에는 행위 함수가 없다고 했음..)
    • 행위 함수와 속성은 클래스에서 별개로 취급됨
    • 클래스 내의 위치와 상관없이 속성은 언제나 특정 객체에 대해 같은 메모리 블록 안에서 수집됨
    • 함수는 속성과는 언제나 독립적으로 존재함 ⇒ 암묵적 캡슐화

• C에서 상속을 구현하는 첫 번째 접근법에서 다중 상속이 되지 않는 이유

  typedef struct {...} a_t;
  typedef struct {...} b_t;
  
  typedef struct {
  	a_t a;
  	b_t b;
  	...
  } c_t;
  
  c_t c_obj;
  a_t* a_ptr = (a_t*)&c_obj;
  b_t* b_ptr = (b_t*)&c_obj;
  c_t* c_ptr = &c_obj;
  

  • c_t 클래스는 a_t 와 b_t 클래스 모두 상속하려고 한다❗
    • 클래스 선언 한 다음에 c_obj 객체를 만들었다
    • 서로 다른 포인터도 만들었다
  • 🚨 이러한 포인터는 모두 반드시 같은 주소를 가리켜야 한다
    • BUT a_ptr 과 c_ptr 포인터는 a_t 및 c_t 클래스의 어느 행위 함수와도 안전하게 사용 가능
    • b_ptr 포인터는 a_t 객체에 해당하는 c_t 클래스 내의 필드를 가리키므로 사용하기 위험
    • b_ptr 포인터 통해 b_t 안에 있는 필드로 접근하려고 한다면 정의되지 않은 행위로 됨

  • 아래는 올바른 필드를 가리키도록 캐스팅 (변환) 을 업데이트 한 예시다

    typedef struct {...} a_t;
    typedef struct {...} b_t;
    
    typedef struct {
    	a_t a;
    	b_t b;
    	...
    } c_t;
    
    c_t c_obj;
    a_t* a_ptr = (a_t*)&c_obj;
    // ⬇️ 밑에 바뀜
    b_t* b_ptr = (b_t*)(&c_obj + sizeof(a_t));
    c_t* c_ptr = &c_obj;
    

    • 🚨 c_obj 의 주소에 대한 a_t 객체의 크기를 추가함
      • c_t 내부의 b 필드를 가리키는 포인터가 된다
      • 형번환 : 자료형을 변환하기 위해 존재하며, 앞에 예에서는 메모리 주소에 해당하는 전송값을 수정하지는 않음!
      • 할당 이후에는 결국 오른쪽의 주소가 왼쪽으로 복사된다

• C++ 에서의 다중 상속

  // File name: ExtremeC_examples_chapter9_3.cpp
  // Description: Multiple inheritance in C++
  
  #include <string.h>
  
  class A {
  public:
    char a; // A
    char b[4]; // BBB
  };
  
  class B {
  public:
    char c; // C
    char d;  // D
  };
  
  class C {
  public:
    char e;  // E
    char f;  // F
  };
  
  class D : public A, public B, public C {
  public:
    char str[5];  // 1234
  };
  
  int main(int argc, char** argv) {
    D d;
    d.a = 'A';
    strcpy(d.b, "BBB");
    d.c = 'C';
    d.d = 'D';
    d.e = 'E';
    d.f = 'F';
    strcpy(d.str, "1234");
    A* ap = &d;
    B* bp = &d;
    C* cp = &d;
    D* dp = &d;
    // We need to set a break point at this line.
    return 0;
  }
  

  g++ -g ExtremeC_examples_chapter9_3.cpp -o ex9_3.out
  gdb ./ex9_3.out
  

  • 속성은 서로 인접한 곳에 있음
    • 부모 클래스에 대한 여러 객체가 d 객체의 메모리 레이아웃과 같은 곳 내부에 있음을 나타냄
  • ap, bp, cp, dp 포인터는 ❓
    • C++ 에서는 자식 포인터를 부모 포인터로 할당할 때 (업캐스팅) 압묵적으로 형변환 가능
    • $4 로 나타나는 d 객체에 대한 시작 주소를 보여줌
      • $1 로 나타나는 ap 가 가리키는 주소와 같음 ⇒ C++ 에서 D 클래스의 속성 구조체에 대응하는 첫 번째 필드로써 A 자료형에 대한 객체를 둔다는 점이 명확해짐
    • 포인터에 있는 주소와 x 명령어로 얻은 결과를 토대로, B 자료형과 C 자료형의 객체는 객체 d에 속하는 메모리 레이아웃과 같은 곳에 있음
    • 앞의 주소는 C++ 에서의 형변환이 수동 작업이 아니라는 점을 나타냄
    • 자료형을 변환할 때 전송하는 주소에 대한 포인터 연산을 수행할 수 있음을 보여줌
      • EX) bp 포인터를 할당할 때, 5바이트 또는 sizeof(A) 가 d의 주소에 추가된다
      • C 에서 다중 상속을 구현하는 과정에서 발견되는 문제를 극복하려는 것..
      • C++ 이들 포인터는 산술 연산 필요 없이 모든 행위 함수 내에서 쉽게 사용 할 수 있음
      • But,, C 의 형변환 처럼 C++ 의 형변환도 수동적일 것이라 가정한다면,, 다를 것임 ❗

☑️ 9.2.3 다형성

• C 에서 다형적인 행위 함수는 간단함

• C++ 에서 다형성을 가지려면 더 복잡한 메커니즘 사용함

  • C 코드에서 가상 함수가 선언 및 정의되는 방식

    // 함수 포인터 자료형 정의하기
    typedef void* (*func_1_t)(void*, ...);
    typedef void* (*func_2_t)(void*, ...);
    ...
    typedef void* (*func_n_t)(void*, ...);
    
    // 부모 클래스에 대한 속성 구조체
    typedef struct {
     // 속성
     ...
     // 함수에 대한 포인터
     func_1_t func_1;
     func_2_t func_2;
     ...
     func_n_t func_t;
    } parent_t;
    
    // 가상 행위 함수에 대한 기본 비공개 정의
    void* __default_func_1(void* parent, ...) { // 기본 의
    }
    void* __default_func_2(void* parent, ...) { // 기본 의
    }
    ...
    void* __default_func_n(void* parent, ...) { // 기본 의
    }
    
    // 생성자
    void parent_ctor(parent_t *parent) {
     // 속성 초기화하기
     ...
     // 가상 행위 함수에 대한 기본 정의 설정하기
     parent->func_1 = __default_func_1;
     parent->func_2 = __default_func_2;
     ...
     parent->func_n = __default_func_n;
    }
    
    // 공용인 비가상 행위 함수
    void* parent_non_virt_func_1(parent_t* parent, ...) { // Code }
    void* parent_non_virt_func_2(parent_t* parent, ...) { // Code }
    ...
    void* parent_non_virt_func_m(parent_t* parent, ...) { // Code }
    
    // 실제 공용 가상 행위 함수들
    void* parent_func_1(parent_t* parent, ...) {
     return parent->func_1(parent, ...);
    }
    void* parent_func_2(parent_t* parent, ...) {
     return parent->func_2(parent, ...);
    }
    ...
    void* parent_func_n(parent_t* parent, ...) {
     return parent->func_n(parent, ...);
    }
    

    • 부모 클래스는 속성 구조체 내부에 함수 포인터에 대한 목록을 갖고 있어야 함
    • 부모 클래스의 이러한 함수 포인터는 가상 함수에 대한 기본 정의를 가리킴
      • 그렇지 않으면 NULL 값 가짐
    • 정의된 의사 클래스는 m 이라는 비가상 행위 함수와 n 이라는 가상 행위 함수 가짐
      • 비가상 함수는 다형적이지 않음

        //구현 대신 가상함수에 NULL (0)값을 대입하면 해당 함수는 순수 가상함수가 됩니다
        virtual void function() = 0;
        

        • 비가상 함수를 호출해 다양한 행위를 얻을 수 없음
        • 즉, 비가상 함수에 대한 호출은 단순한 함수 호출에 지나지 않으며!
        • 정의 내부의 로직만을 수행할 뿐 다른 함수로 호출을 전달하지 않음
      • 가상 함수는 부모 또는 자식 생성자에 의해 설정된 적절한 함수로 호출을 다시 전달해야 함

        // C++에서 가상 함수는 virtual 키워드를 사용하여 선언합니다.
        
        virtual function(){
          ...
        }
        

        • 상속된 가상 함수의 일부를 자식 클래스가 다시 정의하려면 가상 함수 포인터를 업데이트 해야 함

• 자식 클래스가 몇몇 가상 함수를 오버라이딩 하는 법을 나타냄

  • 자식 클래스가 부모 클래스로부터 상속받은 가상 함수를 오버라이딩 하는 방법

    // 부모 클래스에 관련된 모든 것을 포함하세요
    
    typedef struct {
     parent_t parent;
     // 자식 속성
     ...
    } child_t;
    
    void* __child_func_4(void* parent, ...) { // 오버라이딩 정의
    }
    void* __child_func_7(void* parent, ...) { // 오버라이딩 정의
    }
    
    void child_ctor(child_t* child) {
     parent_ctor((parent_t*)child);
     // 자식 속성 초기화하기
     ...
     // 함수에 대한 포인터 업데이트 하기
     child->parent.func_4 = __child_func_4;
     child->parent.func_7 = __child_func_7;
    }
    
    // 자식의 행위 함수
    ...
    

    • 자식 클래스는 부모의 속성 구조체 안에 있는 몇몇 포인터에 대한 업데이트만 필요
      • C++ 에서도 비슷한 접근법 취함
      • virtual 키워드를 사용해 행위 함수를 가상으로 선언 할 때 C++ 는 함수 포인터의 배열을 만든다
    • 각각의 가상 함수에 대해 함수 포인터 속성 하나를 추가했음
      • C++ 에서는 이러한 포인터를 두는데 더 영리함
        • 🚨 가상 테이블 또는 vtable 이라는 배열만 사용함
        • 가상 테이블은 객체가 생성되려고 할 때 만들어진다
        • 가상 테이블은 기초 클래스에 대한 생성자를 호출할 때 처음 추가 됨
        • 그 뒤에, 자식 클래스의 생성자의 일부가 된다
        • 가상 테이블은 생성자에서만 추가되는 만큼, 부모 및 자식 클래스 모두 생성자에서 다형적 메서드를 호출하지 않아야 함
        • 포인터가 업데이트 되지 않았을 수도 있고, 틀린 정의를 가리킬 수 있음

☑️ 9.2.4 추상 클래스

• C++ 에서 추상화는 순수 가상 함수를 사용할 수 있음

• C++ 에서 멤버 함수를 가상 함수라고 정의하고 이를 0으로 둔다면, 순수 가상 함수를 정의 한 것!

  • C++의 Eatable 인터페이스

    enum class Taste { Sweet, Sour };
    
    // 인터페이스
    class Eatable {
    public:
    	virtual Taste GetTaste() = 0;
    }
    

    • Eatable 클래스 내부에 0 으로 설정한 GetTaste 라는 가상 함수가 있음
    • GetTaste 는 순수 가상 함수 이며, 전체 클래스를 추상화 함
    • Eatable 자료형으로부터 더 이상 객체를 생성 할 수 없으며, C++ 가 이를 허용하지 않음
      • Eatable 은 인터페이스인데, Eatable 의 모든 멤버 함수가 순수하게 가상이기 때문
    • 이 함수는 자식 클래스에 의해 오버라이딩 될 수 있음

  • C++의 Eatable 인터페이스를 구현하는 자식 클래스 (GetTaste 함수를 오버라이딩 하는 클래스)

    enum class Taste { Sweet, Sour };
    
    // 인터페이스
    class Eatable {
    public:
    	virtual Taste GetTaste() = 0;
    }
    
    class Apple : public Eatable {
    public:
     Taste GetTaste() override {
     return Taste::Sweet;
     }
    };
    

    • 순수 가상 함수는 가상 함수와 상당히 비슷함
    • 실제 정의에 대한 주소는 가상 함수와 마찬가지 방식으로 가상 테이블 내에 있음
    • 순수 가상 함수에 대한 포인터의 초깃값은 NULL
      • 일반적인 가상 함수의 포인터와는 다름
      • 일반적인 가상 함수의 포인터는 생성이 진행되는 동안 기본 정의를 가리켜야 함
    • 추상 자료형에 대해서 아무것도 알지 못하는 C 컴파일러와 달리 - C++ 컴파일러는 추상 자료형을 알고 있음 - 만약, 추상 자료형으로부터 객체를 생성하려고 한다면 컴파일 오류 발생

      순수 가상 함수에 대한 포인터의 초깃값은 NULL

      • 일반적인 가상 함수의 포인터와는 다름
      • 일반적인 가상 함수의 포인터는 생성이 진행되는 동안 기본 정의를 가리켜야 함

      🚨 추상 클래스는 먼저 상속을 통해 파생 클래스를 만들고, 만든 파생 클래스에서 순수 가상 함수를 모두 오버라이딩하고 나서야 비로소 파생 클래스의 인스턴스를 생성할 수 있게 됩니다. (하지만 추상 클래스 타입의 포인터와 참조는 바로 사용 가능)

⭐ 9.3 마무리

• 추상 자료형과 인터페이스를 다룸
  • 이를 통해 인터페이스 또는 추상적인 클래스를 가질 수 있음
  • 이 부분적인 추상 클래스는 다형성을 갖는 더 구체적인 자식 클래스 및 다른 행위를 만들 때 사용 가능
• OOP 기능을 도입하기 위해 C에서 사용하는 기법에 관한 출력 결과를 g++ 의 출력 결과와 비교하고, 그 결과가 얼마나 비슷한지 설명함 (매우 유사함)
• 가상 테이블 상세히 다룸
• 순수 가상 함수 (C++ 개념이지만 C 에도 해당하는 개념 있음) 가 기본 정의를 갖지 않는 가상 행위를 선언하기 위해 사용하는 방법 보여줌