🐢 chap8. 상속과 다형성

⭐ 8.1 상속

상속 관계: to-be 관계, 확장 관계extention relationship

어떤 객체가 다른 객체와 같은 속성을 갖고 있는데 다른 추가 속성을 가진 경우

예) 학생은 사람이라는 모든 속성을 갖고 있으나 다른 추가 속성을 가질 수 있음

• 코드 박스 8-1 (p.316)

Person 클래스와 Student 클래스 속성 구조체

→ 새로운 속성으로 확장, to be 관계, ‘학생은 사람이다’

person_t: 슈퍼타입supertype, 베이스타입base type, 부모 타입parent type

student_t: 자식 타입child type, 상속받은 서브타입inherited subtype

☑️ 상속의 본질

상속 관계: 일대일 합성 관계

Student 클래스의 속성 구조체 내부에 비공개 person 객체가 존재

→학생 내부에 인간의 속성을 가짐

• 코드 박스 8-2 (p.317)

Person 클래스와 Student 클래스 속성 구조체(중첩됨)

→ 포인터가 아닌 구조체 변수 사용, 이전 구조체를 상속한 새 구조체 내부에 구조체 변수를 가짐

업캐스팅: 자식의 속성 구조체 자료형의 포인터를 부모 속성 구조체 자료형으로 변환

student_t 포인터를 person_t 포인터로 변환할 수 있음

• 예제 8-1 (p.318)

  #include <stdio.h>
  
  typedef struct {
    char first_name[32];
    char last_name[32];
    unsigned int birth_year;
  } person_t;
  
  typedef struct {
    person_t person;
    char student_number[16]; // 추가 속성
    unsigned int passed_credits; // 추가 속성
  } student_t;
  
  int main(int argc, char** argv) {
    student_t s;
    student_t* s_ptr = &s;
    person_t* p_ptr = (person_t*)&s;
    printf("Student pointer points to %p\n", (void*)s_ptr);
    printf("Person pointer points to %p\n", (void*)p_ptr);
    return 0;
  }
  

  s_ptr과 p_ptr 포인터는 메모리에서 같은 주소를 가리킴

  gcc ExtremeC_examples_chapter8_1.c -o ex8_1.out
  ./ex8_1.out
  //Student pointer points to 0x7ffeb64e6500
  //Person pointer points to 0x7ffeb64e6500
  

  student_t형의 구조체 변수가 person_t 구조체를 상속한다는 뜻

  → student 객체를 가리키는 포인터로 Person 클래스의 행위 함수 사용 가능

• 코드 박스 8-3 (p.319)

컴파일되지 않는 상속 관계 만들기

불완전한 형식 선언→변수 생성 불가능, 힙 메모리 할당 불가능

중첩된 구조체 변수 사용을 위해서는 student_t 구조체가 비공개인 person_t 구조체의 실제 정의를 알아야 함

상속 관계 구현을 위한 접근 방법

1. 자식 클래스가 베이스 클래스에 대한 비공개 구현에 접근
2. 자식 클래스가 베이스 클래스의 공용 인터페이스에만 접근

☑️ C의 상속에 관한 첫 번째 접근법

첫 번째 접근법에 대해 예제 8-2에서 설명

Student 클래스는 Person 클래스의 속성 구조체에 대한 실제 비공개 정의에 접근할 수 있어야 함

• 예제 8-2

  #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_2_PERSON_H
  #define EXTREME_C_EXAMPLES_CHAPTER_8_2_PERSON_H
  
  // 전방 선언
  struct person_t;
  
  // 메모리 할당자
  struct person_t* person_new();
  
  // 생성자
  void person_ctor(struct person_t*,
                   const char*  /* first name */,
                   const char*  /* last name */,
                   unsigned int /* birth year */);
  
  // 소멸자
  void person_dtor(struct person_t*);
  
  // 행위 함수
  void person_get_first_name(struct person_t*, char*);
  void person_get_last_name(struct person_t*, char*);
  unsigned int person_get_birth_year(struct person_t*);
  
  #endif
  

  Person 클래스를 선언하는 헤더 파일 생성자 함수→person 객체 생성을 위한 모든 값을 받음 속성 구조체 person_t에 대한 실제 정의를 포함하면 안됨(캡슐화)→비공개 헤더 파일(이 헤더의 실제 정의를 포함하는 헤더 파일)

  #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_2_PERSON_P_H
  #define EXTREME_C_EXAMPLES_CHAPTER_8_2_PERSON_P_H
  
  // 비공개 정의
  typedef struct {
    char first_name[32];
    char last_name[32];
    unsigned int birth_year;
  } person_t;
  
  #endif
  

  이는 Person 클래스의 일부분, student_t 속성 구조체를 정의하기 위해 필요

  #include <stdlib.h>
  #include <string.h>
  
  // person_t는 다음 헤더 파일에 정의되어 있습니다.
  #include "ExtremeC_examples_chapter8_2_person_p.h"
  
  // 메모리 할당자
  person_t* person_new() {
    return (person_t*)malloc(sizeof(person_t));
  }
  
  // 생성자
  void person_ctor(person_t* person,
                   const char* first_name,
                   const char* last_name,
                   unsigned int birth_year) {
    strcpy(person->first_name, first_name);
    strcpy(person->last_name, last_name);
    person->birth_year = birth_year;
  }
  
  // 소멸자
  void person_dtor(person_t* person) {
    // 할 일 없음
  }
  
  // 행위 함수
  void person_get_first_name(person_t* person, char* buffer) {
    strcpy(buffer, person->first_name);
  }
  
  void person_get_last_name(person_t* person, char* buffer) {
    strcpy(buffer, person->last_name);
  }
  
  unsigned int person_get_birth_year(person_t* person) {
    return person->birth_year;
  }
  

  Person 클래스의 비공개 구현을 나타냄

  #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_2_STUDENT_H
  #define EXTREME_C_EXAMPLES_CHAPTER_8_2_STUDENT_H
  
  // 전방 선언
  struct student_t;
  
  // 메모리 할당자
  struct student_t* student_new();
  
  // 생성자
  void student_ctor(struct student_t*,
                    const char*  /* first name */,
                    const char*  /* last name */,
                    unsigned int /* birth year */,
                    const char*  /* student number */,
                    unsigned int /* passed credits */);
  
  // 소멸자
  void student_dtor(struct student_t*);
  
  // 행위 함수
  void student_get_student_number(struct student_t*, char*);
  unsigned int student_get_passed_credits(struct student_t*);
  
  #endif
  

  Student 클래스의 공용 인터페이스를 나타냄 student 객체가 실제로 person 객체를 포함→Person 클래스의 생성자와 비슷한 인자를 받음 행위 함수가 2개뿐: Person 클래스의 행위 함수를 사용할 수 있기 때문

  #include <stdlib.h>
  #include <string.h>
  
  #include "ExtremeC_examples_chapter8_2_person.h"
  
  // 1. person_t는 다음 헤더 파일에 정의되어 있으며 여기에서 필요합니다.
  #include "ExtremeC_examples_chapter8_2_person_p.h"
  
  // 전방 선언
  typedef struct {
    // 2. 여기에서 person 클래스에서 모든 속성을 상속받으며,
    // 이 중첩으로 인해 person 클래스의 모든 행위 함수를 사용할 수 있습니다.
    person_t person;
    char* student_number;
    unsigned int passed_credits;
  } student_t;
  
  // 메모리 할당자
  student_t* student_new() {
    return (student_t*)malloc(sizeof(student_t));
  }
  
  // 생성자
  void student_ctor(student_t* student,
                    const char* first_name,
                    const char* last_name,
                    unsigned int birth_year,
                    const char* student_number,
                    unsigned int passed_credits) {
    // 3. 부모 클래스에 대한 생성자 호출하기
    person_ctor((struct person_t*)student,
            first_name, last_name, birth_year);
    student->student_number = (char*)malloc(16 * sizeof(char));
    strcpy(student->student_number, student_number);
    student->passed_credits = passed_credits;
  }
  
  // 소멸자
  void student_dtor(student_t* student) {
    // 4. 자식 객체를 먼저 소멸시켜야 합니다.
    free(student->student_number);
    // 그런 다음, 부모 클래스의 소멸자 함수를 호출해야 합니다.
    person_dtor((struct person_t*)student);
  }
  
  // 행위 함수
  void student_get_student_number(student_t* student,
                                  char* buffer) {
    strcpy(buffer, student->student_number);
  }
  
  unsigned int student_get_passed_credits(student_t* student) {
    return student->passed_credits;
  }
  

  1. Person 클래스의 비공개 헤더를 포함
  2. person_t가 이미 정의되어 있어야 함
  3. 부모의 생성자 호출→부모 객체에 대한 속성을 초기화
  4. 자식 수준 다음 부모 수준에서 소멸자를 호출

  #include <stdio.h>
  #include <stdlib.h>
  
  #include "ExtremeC_examples_chapter8_2_person.h"
  #include "ExtremeC_examples_chapter8_2_student.h"
  
  int main(int argc, char** argv) {
    // student 객체를 만들고 생성하기
    struct student_t* student = student_new();
    student_ctor(student, "John", "Doe",
            1987, "TA5667", 134);
  
    // 이제 person의 속성을 student 객체에서 읽기 위해 person의 행위 함수를 사용합니다.
    char buffer[32];
  
    // 부모의 자료형에 대한 포인터로 업캐스팅하기
    struct person_t* person_ptr = (struct person_t*)student;
  
    person_get_first_name(person_ptr, buffer);
    printf("First name: %s\n", buffer);
  
    person_get_last_name(person_ptr, buffer);
    printf("Last name: %s\n", buffer);
  
    printf("Birth year: %d\n", person_get_birth_year(person_ptr));
  
    // 이제 student 객체에 한정된 속성을 읽습니다.
    student_get_student_number(student, buffer);
    printf("Student number: %s\n", buffer);
  
    printf("Passed credits: %d\n",
            student_get_passed_credits(student));
  
    // student 객체를 소멸 및 해제하기
    student_dtor(student);
    free(student);
  
    return 0;
  }
  

  Person과 Student 클래스 모두에 대한 공용 인터페이스를 포함, but 객체는 student만 생성 student는 person 객체에서 모든 속성을 상속 받음→Person 클래스의 행위 함수로 읽을 수 있음

  gcc -c ExtremeC_examples_chapter8_2_person.c -o person.o
  gcc -c ExtremeC_examples_chapter8_2_student.c -o student.o
  gcc -c ExtremeC_examples_chapter8_2_main.c -o main.o
  gcc person.o student.o main.o -o ex8_2.out
  ./ex8_2.out
  //First name: John
  //Last name: Doe
  //Birth year: 1987
  //Student number: TA5667
  //Passed credits: 134
  

☑️ C의 상속에 관한 두 번째 접근법

두 번째 접근법에 대해 예제 8-3에서 설명

부모의 구조체 변수를 가리키는 포인터 생성→자식 클래스는 부모 클래스 구현과 독립적→정보 은닉

예제 8-3은 8-2와 매우 비슷하지만, Student가 Person클래스의 비공개 정의에는 의존하지 않는다는 차이 존재→자식 클래스 구현을 변경하지 않고도 부모 클래스 구현 변경 가능

예제 8-2는 person_t의 실제 정의에 접근→정보 은닉 원리 위반 가능성

• 예제 8-3

  // 전방 선언
  struct student_t;
  
  // 메모리 할당자
  struct student_t* student_new();
  
  // 생성자
  void student_ctor(struct student_t*,
                    const char*  /* first name */,
                    const char*  /* last name */,
                    unsigned int /* birth year */,
                    const char*  /* student number */,
                    unsigned int /* passed credits */);
  
  // 소멸자
  void student_dtor(struct student_t*);
  
  // 행위 함수
  void student_get_first_name(struct student_t*, char*);
  void student_get_last_name(struct student_t*, char*);
  unsigned int student_get_birth_year(struct student_t*);
  void student_get_student_number(struct student_t*, char*);
  unsigned int student_get_passed_credits(struct student_t*);
  
  #endif
  

  Student 클래스의 새로운 공용 인터페이스: 첫 번째 접근법과 달리 두 번째 접근법에서는 Student 클래스의 공용 인터페이스가 변경되어야 한다. student_t 포인터를 person_t 포인터로 변환할 수 없음→업캐스팅 불가능→Student 클래스는 Person 클래스에서 선언한 모든 행위 함수를 반복해야 함(p.323과 비교)

  #include <stdlib.h>
  #include <string.h>
  
  // 비공개 정의
  typedef struct {
    char first_name[32];
    char last_name[32];
    unsigned int birth_year;
  } person_t;
  
  // 메모리 할당자
  person_t* person_new() {
    return (person_t*)malloc(sizeof(person_t));
  }
  
  // 생성자
  void person_ctor(person_t* person,
                   const char* first_name,
                   const char* last_name,
                   unsigned int birth_year) {
    strcpy(person->first_name, first_name);
    strcpy(person->last_name, last_name);
    person->birth_year = birth_year;
  }
  
  // 소멸자
  void person_dtor(person_t* person) {
    // 할 일 없음
  }
  
  // 행위 함수
  void person_get_first_name(person_t* person, char* buffer) {
    strcpy(buffer, person->first_name);
  }
  
  void person_get_last_name(person_t* person, char* buffer) {
    strcpy(buffer, person->last_name);
  }
  
  unsigned int person_get_birth_year(person_t* person) {
    return person->birth_year;
  }
  

  Person 클래스의 새로운 구현: person_t의 비공개 정의가 소스 내에 존재, 비공개 헤더 파일이 사용되지 않음(p.321과 비교)→Student 클래스 같은 타 클래스와 정의를 공유하지 않겠다는 뜻(Person 클래스에 대한 캡슐화)

  #include <stdlib.h>
  #include <string.h>
  
  // 1. person 클래스에 대한 공용 인터페이스
  #include "ExtremeC_examples_chapter8_3_person.h"
  
  // 전방 선언
  typedef struct {
    char* student_number;
    unsigned int passed_credits;
    // 2. person_t가 불완전한 형식이기 때문에 여기에 포인터가 있어야 합니다.
    struct person_t* person;
  } student_t;
  
  // 메모리 할당자
  student_t* student_new() {
    return (student_t*)malloc(sizeof(student_t));
  }
  
  // 생성자
  void student_ctor(student_t* student,
                    const char* first_name,
                    const char* last_name,
                    unsigned int birth_year,
                    const char* student_number,
                    unsigned int passed_credits) {
    // 3. 부모 객체에 대한 메모리 할당하기
    student->person = person_new();
    person_ctor(student->person, first_name,
            last_name, birth_year);
    student->student_number = (char*)malloc(16 * sizeof(char));
    strcpy(student->student_number, student_number);
    student->passed_credits = passed_credits;
  }
  
  // 소멸자
  void student_dtor(student_t* student) {
    // 먼저 자식 객체를 소멸시켜야 합니다.
    free(student->student_number);
    // 그런 다음, 부모 클래스의 소멸자 함수를 호출해야 합니다.
    person_dtor(student->person);
    // 그리고 부모 객체에 할당된 메모리를 해제해야 합니다.
    free(student->person);
  }
  
  // 4. 행위 함수
  void student_get_first_name(student_t* student, char* buffer) {
    // person의 행위 함수를 사용해야 합니다.
    person_get_first_name(student->person, buffer);
  }
  
  void student_get_last_name(student_t* student, char* buffer) {
    // person의 행위 함수를 사용해야 합니다.
    person_get_last_name(student->person, buffer);
  }
  
  unsigned int student_get_birth_year(student_t* student) {
    // person의 행위 함수를 사용해야 합니다.
    return person_get_birth_year(student->person);
  }
  
  void student_get_student_number(student_t* student,
                                  char* buffer) {
    strcpy(buffer, student->student_number);
  }
  
  unsigned int student_get_passed_credits(student_t* student) {
    return student->passed_credits;
  }
  

  Student 클래스의 새로운 구현(p.324와 비교)

  1. Person 클래스의 공용 인터페이스를 헤더 파일에 포함
  2. student_t의 정의 부분: 포인터 필드 추가, 첫번째 필드일 필요는 x, 상호변환 할 수 없음
  3. 부모 객체를 인스턴스화
  4. Student 클래스는 자신의 행위 함수들을 노출, 래퍼 함수 노출→Student 객체 자체로는 Person 객체의 비공개 속성을 알 수 없음

  #include <stdio.h>
  #include <stdlib.h>
  
  #include "ExtremeC_examples_chapter8_3_student.h"
  
  int main(int argc, char** argv) {
    // student 객체를 만들고 생성하기
    struct student_t* student = student_new();
    student_ctor(student, "John", "Doe",
            1987, "TA5667", 134);
  
    // student 포인터는 person 포인터가 아니며
    // student 객체에 있는 비공개 부모 포인터에 접근할 수 없으므로,
    // student의 행위 함수를 사용해야 합니다.
    char buffer[32];
    student_get_first_name(student, buffer);
    printf("First name: %s\n", buffer);
  
    student_get_last_name(student, buffer);
    printf("Last name: %s\n", buffer);
  
    printf("Birth year: %d\n", student_get_birth_year(student));
  
    student_get_student_number(student, buffer);
    printf("Student number: %s\n", buffer);
  
    printf("Passed credits: %d\n",
            student_get_passed_credits(student));
  
    // student 객체 소멸 및 해제하기
    student_dtor(student);
    free(student);
  
    return 0;
  }
  

  person.h 포함x→Person 클래스의 행위 함수 사용x(p.325와 비교)

  gcc -c ExtremeC_examples_chapter8_3_person.c -o person.o
  gcc -c ExtremeC_examples_chapter8_3_student.c -o student.o
  gcc -c ExtremeC_examples_chapter8_3_main.c -o main.o
  gcc person.o student.o main.o -o ex8_3.out
  ./ex8_3.out
  //First name: John
  //Last name: Doe
  //Birth year: 1987
  //Student number: TA5667
  //Passed credits: 134
  

  출력 결과는 같음

☑️ 두 가지 접근법 비교하기

• 첫 번째 접근법

  • 합성 관계
  • 자식의 속성 구조체 안에 구조체 변수 존재
  • 부모 클래스가 비공개 구현에 접근하는 데에 의존
  • 부모와 자식의 자료형은 매우 의존적
  • 부모가 오직 하나
  • C의 단일 상속 sngle inertance을 구현
  • 부모의 구조체 변수는 자식 클래스의 속성 구조체의 첫 번째 필드
  • 부모 클래스의 행위 함수를 사용

• 두 번째 접근법

  • 합성 관계
  • 부모의 속성 구조체의 불완전 자료형으로부터 구조체 포인터를 두므로 부모 클래스의 비공개 구현에 의존하지 않음
  • 클래스들은 서로에 대해 독립적
  • 부모의 구현 내부에 있는 모든 것은 자식에게 숨겨져 있음
  • 원하는 만큼 많은 부모를 가질 수 있으므로 다중 상속mutpe nhertanceo라는 개념
  • 부모 객체에 대한 포인터를 구조체 내의 어디든
  • 자식 클래스의 새로운 행위 함수를 통해 부모의 행위 함수를 전달

⭐ 8.2 다향성 소개

❓다향성이란 → 서로 다른 행위를 갖는 같은 코드(공용 인터페이스)를 두는 기법입니다.

→ 다향성을 통해 전체 코드베이스를 다시 컴파일하지 않고도 코드를 상속하거나 기능을 추가할 수 있습니다.

• Animal, Cat, Duck 자료형에 대한 객체 세 개를 생성하기

  struct animal_t*animal = animal_malloc();
  animal_ctor(animal);
  
  struct cat_t*cat = cat_malloc();
  cat_ctor(cat);
  
  struct duck_t*duck = duck_malloc();
  duck_ctor(aduck);
  
  

  • cat과 duck클래스는 animal클래스의 자식이라고 가정합니다. 이때 다향성이 없다면 sound 함수를 각 객체에서 호출했을 겁니다.

  animal_sound(animal);
  cat_sound(cat);
  duck_sound(duck);
  

  • 하지만 다형적 함수가 실행된다면 다음과 같이 호출됩니다.

  animal_sound(animal);
  animal_sound((struct animal_t*)cat);
  animal_sound((struct animal_t*)duck);
  

  • animal_sound가 다형적이라면 다른 객체 포인터를 전달했을 때 각자 다른 소리가 출력 될 것입니다. 같은 animal_sound를 사용했지만 포인터는 다른 것으로 사용하였기 때문에 다른 함수들을 내부에서 불러왔습니다.

  • 이 코드는 다형적 코드로 Animal이라는 클래스와 함께 Cat , Duck 클래스와 상속 관계입니다. duck_t와 cat_t 포인터를 animal_t 포인터로 변환하려고 하기 때문입니다.

  typedef struct {
  ...
  }animal_t
  
  typedef struct {
  aniaml_t animal;
  ...
  }cat_t;
  
  typedef struct{
  aniaml_t animal;
  ...
  }duck_t;
  

  • 상속을 구현하는 첫 번째 방법으로 자식 클래스는 부모 클래스의 비공개 구현에 접근했으며, 여기서 duck_t와 cat_t 속성 구조체 정의의 첫 번째 필드로 animal_t 자료형인 구조체 변수를 두어야 했습니다.
  • 이 설정을 통해서 duck_t와 cat_t 포인터를 animal_t 포인터로 변환할 수 있습니다. 그리고 난 뒤 두 자식 클래스에 대한 행위 함수를 사용할 수 있습니다.

☑️ 다향성이 필요한 이유

→ 현재의 로직을 자주 수정하고 싶지는 않을 때 다향성을 이용하면 필요한 변경 횟수를 크게 줄일 수 있습니다.

→ 추상화 때문에 다향성이 필요합니다. 추상적인 자료형(클래스)를 가질 때, 자식 클래스에서는 오버라이딩이 되어야 하는 행위를 갖는데 이때 다향성이 핵심적입니다.

☑️ C에서 다형적 행위를 갖는 방법

C에서 다향성을 가질려면 상속을 구현하는 첫 번째 접근법을 가져야합니다. 또한 다향적 행위를 달성하려면 함수 포인터를 이용할 수 있습니다. 이러한 함수 포인터를 속성 구조체 내의 필드에 두어야 합니다.

• 예제 8-4

  • Animal 클래스의 공용 인터페이스

    // File name: ExtremeC_examples_chapter8_4_animal.h
    // Description: Public interface of the animal class
    
    #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_4_ANIMAL_H
    #define EXTREME_C_EXAMPLES_CHAPTER_8_4_ANIMAL_H
    
    // Forward declaration
    struct animal_t;
    
    // Memory allocator
    struct animal_t* animal_new();
    
    // Constructor
    void animal_ctor(struct animal_t*);
    
    // Destructor
    void animal_dtor(struct animal_t*);
    
    // Behavior functions
    void animal_get_name(struct animal_t*, char*);
    void animal_sound(struct animal_t*);
    
    #endif
    

    • Animal 클래스의 공용 인터페이스에서는 2개의 행위함수를 가집니다.
      • animal_sound 함수는 다형적으로, 자식 클래스에서 오버라이딩이 될 수 있습니다.
      • animal_get_name은 다형적이지 않으며 자식 클래스가 오버라이딩이 될 수 없습니다.

  • Animal 클래스의 비공개 헤더 (Animal 클래스의 속성 구조체에 관한 실제 정의 포함)- 상속을 구현하는 첫번째 접근법으로 취합니다

    // File name: ExtremeC_examples_chapter8_4_animal_p.h
    // Description: Private defintion of the attribute structure
    //              of the animal class
    
    #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_4_ANIMAL_P_H
    #define EXTREME_C_EXAMPLES_CHAPTER_8_4_ANIMAL_P_H
    
    // 가리키는데 필요한 함수 포인터형
    // different morphs of animal_sound
    typedef void (*sound_func_t)(void*);
    
    // Forward declaration
    typedef struct {
      char* name;
      // This member is a pointer to the function which
      // performs the actual sound behavior
      sound_func_t sound_func;
    } animal_t;
    
    #endif
    

    • 모든 자식 클래스는 부모 클래스로부터 상속 받은 함수를 오버라이딩 할 수 있습니다.
    • 오버라이딩하려는 각각의 자식 클래스에 대한 다른 함수를 가져야 합니다.
      • 이러한 이유로 함수 포인터를 사용합니다.
    • 즉 모든 자식 클래스는 animal_sound 함수에 대한 자신만의 버전을 제공 할 수 있고, 자식 클래스가 animal_sound를 오버라이딩했다면, 오버라이딩된 함수가 호출되어야하고 이때 함수 포인터를 사용합니다.
      • animal_t의 각 인스턴스(클래스에서 현재 생성된 객체)는 animal_sound 행위 전용의 함수 포인터를 가질 것이고, 그 포인터는 클래스 내의 다형적 함수에 대한 실제 정의를 가리킵니다.

  • Animal 클래스에 대한 정의

    // File name: ExtremeC_examples_chapter8_4_animal.c
    // Description: Private definition of the behavior functions
    //              of the animal class
    
    #include <stdlib.h>
    #include <string.h>
    #include <stdio.h>
    
    #include "ExtremeC_examples_chapter8_4_animal_p.h"
    
    // Default definition of the animal_sound at the parent level
    void __animal_sound(void* this_ptr) { //__animal_sound는 animal_sound 함수의 기본 행위가 되어야함.
      animal_t* animal = (animal_t*)this_ptr;
      printf("%s: Beeeep\n", animal->name);
    }
    
    // Memory allocator
    animal_t* animal_new() {
      return (animal_t*)malloc(sizeof(animal_t));
    }
    
    // Constructor
    void animal_ctor(animal_t* animal) {
      animal->name = (char*)malloc(10 * sizeof(char));
      strcpy(animal->name, "Animal");
      // Set the function pointer to point to the default definition
      animal->sound_func = __animal_sound;
    } //__animal_sound의 주소를 animal 객체의 함수 포인터인 sound_func에 저장
    // 이 설정으로 모든 자식 객체는 이 함수 포인터를 상속하고 함수 포인터는 __animal_sound의 기본 정의를 가르킵니다.
    
    // Destructor
    void animal_dtor(animal_t* animal) {
      free(animal->name);
    }
    
    // Behavior functions
    void animal_get_name(animal_t* animal, char* buffer) {
      strcpy(buffer, animal->name);
    }
    
    void animal_sound(animal_t* animal) {
      // 함수 포인터가 가리키는 함수 호출함.
      animal->sound_func(animal);
    } //sound_func가 다른 함수를 가리킬 때 animal_sound를 불러오면 sound_func가 가리키는 함수가 호출됨.
      //sound_func = __animal_sound에 해당하는 sound 행위의 실제 정의를 가리키는 함수 포인터 필드
    

  • Cat 클래스의 공용 인터페이스

    // File name: ExtremeC_examples_chapter8_4_cat.h
    // Description: Public interface of the cat class
    
    #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_4_CAT_H
    #define EXTREME_C_EXAMPLES_CHAPTER_8_4_CAT_H
    
    // Forward declaration
    struct cat_t;
    
    // Memory allocator
    struct cat_t* cat_new();
    
    // Constructor
    void cat_ctor(struct cat_t*);
    
    // Destructor
    void cat_dtor(struct cat_t*);
    
    // All behavior functions are inherited from the animal class.
    
    #endif
    

    • Cat 클래스는 부모 클래스인 Animal 클래스로부터 sound를 상속 받습니다.

  • Cat 클래스의 비공개 구현

    // File name: ExtremeC_examples_chapter8_4_cat.c
    // Description: Private defintions of the class cat
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include "ExtremeC_examples_chapter8_4_animal.h"
    #include "ExtremeC_examples_chapter8_4_animal_p.h"
    
    typedef struct {
      animal_t animal;
    } cat_t;
    
    // Define a new behavior for the cat's sound
    void __cat_sound(void* ptr) {  //cat의 sound를 위한 새로운 함수인 __cat_sound를 정의
      animal_t* animal = (animal_t*)ptr;
      printf("%s: Meow\n", animal->name);
    }
    
    // Memory allocator
    cat_t* cat_new() {
      return (cat_t*)malloc(sizeof(cat_t));
    }
    
    // Constructor
    void cat_ctor(cat_t* cat) {
      animal_ctor((struct animal_t*)cat);
      strcpy(cat->animal.name, "Cat");
      // Point to the new behavior function. Overriding
      // is actually happening here.
      cat->animal.sound_func = __cat_sound; //오버라이딩 발생
    }
    
    // Destructor
    void cat_dtor(cat_t* cat) {
      animal_dtor((struct animal_t*)cat);
    }
    

    • cat 객체는 **animal_sound 대신에 실제로 **cat_sound를 호출하게 만드는 오버라이딩을 발생시켰습니다.

  • Duck 클래스의 공용 인터페이스

    // File name: ExtremeC_examples_chapter8_4_duck.h
    // Description: Public interface of the duck class
    
    #ifndef EXTREME_C_EXAMPLES_CHAPTER_8_4_DUCK_H
    #define EXTREME_C_EXAMPLES_CHAPTER_8_4_DUCK_H
    
    // Forward declaration
    struct duck_t;
    
    // Memory allocator
    struct duck_t* duck_new();
    
    // Constructor
    void duck_ctor(struct duck_t*);
    
    // Destructor
    void duck_dtor(struct duck_t*);
    
    // All behavior functions are inherited from the animal class.
    
    #endif
    

  • Duck 클래스의 비공개 구현

    // File name: ExtremeC_examples_chapter8_4_duck.c
    // Description: Private defintions of the class duck
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include "ExtremeC_examples_chapter8_4_animal.h"
    #include "ExtremeC_examples_chapter8_4_animal_p.h"
    
    typedef struct {
      animal_t animal;
    } duck_t;
    
    // Define a new behavior for the duck's sound
    void __duck_sound(void* ptr) {
      animal_t* animal = (animal_t*)ptr;
      printf("%s: Quacks\n", animal->name);
    }
    
    // Memory allocator
    duck_t* duck_new() {
      return (duck_t*)malloc(sizeof(duck_t));
    }
    
    // Constructor
    void duck_ctor(duck_t* duck) {
      animal_ctor((struct animal_t*)duck);
      strcpy(duck->animal.name, "Duck");
      // Point to the new behavior function. Overriding
      // is actually happening here.
      duck->animal.sound_func = __duck_sound;
    }
    
    // Destructor
    void duck_dtor(duck_t* duck) {
      animal_dtor((struct animal_t*)duck);
    }
    

    • Duck 클래스 또한 새로운 비공개 행위 함수인 __duck_sound는 duck에 한정된 소리를 내도록 sound행위의 기본 정의를 오버라이딩 했습니다.

  • 메인 시나리오

    // File name: ExtremeC_examples_chapter8_4_main.c
    // Description: Main scenario which calls the
    // polymorphic functions
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // Only public interfaces
    #include "ExtremeC_examples_chapter8_4_animal.h"
    #include "ExtremeC_examples_chapter8_4_cat.h"
    #include "ExtremeC_examples_chapter8_4_duck.h"
    
    int main(int argc, char** argv) {
      struct animal_t* animal = animal_new();
      struct cat_t* cat = cat_new();
      struct duck_t* duck = duck_new();
    
      animal_ctor(animal);
      cat_ctor(cat);
      duck_ctor(duck);
    
      animal_sound(animal);  //다른 포인터를 전달해 함수를 호출하면 다형적 행위가 작동하는 방식을 보여줍니다.
      animal_sound((struct animal_t*)cat);
      animal_sound((struct animal_t*)duck);
    
      animal_dtor(animal);
      cat_dtor(cat);
      duck_dtor(duck);
    
      free(duck);
      free(cat);
      free(animal);
      return 0;
    }
    

    • main함수는 animal, Cat, Duck 클래스의 공용인터페이스만 사용합니다.
      • main함수는 이들 클래스의 내부 구현에 관해서는 아무것도 모르기 때문에 다른 포인터를 전달해 animal_sound 함수를 호출하면 다형적 행위가 작동하는 방식을 보여줍니다.

    gcc -c ExtremeC_examples_chapter8_4_animal.c -o animal.o
    gcc -c ExtremeC_examples_chapter8_4_cat.c -o cat.o
    gcc -c ExtremeC_examples_chapter8_4_duck.c -o duck.o
    gcc -c ExtremeC_examples_chapter8_4_main.c -o main.o
    gcc animal.o cat.o duck.o main.o -o ex8_4.out
    ./ex8_4.out
    
    /********************************************************
    Animal: Beeeep
    Cat: Meow
    Duck: Quacks
    *********************************************************/