🐢 chap6. OOP와 캡슐화

⭐ 6.1 객체지향적 사고

• 우리 주변의 대상을 작게 나누어 분석하는 방법 - 테이블 위의 물병
• 주변의 객체지향적 현실을 마음 반영
• 인간과 상호작용하는 대상object을 모두 포함
• 객체지향적 사고는 우리의 환경을 처리하는 기본 방식이며, 따라서 OOP는 소프트웨어 작성에 가장 보편적으로 사용된 패러다임

6.1.1 정신적 개념

• [코드 박스 6-1] 명명 규칙에 따라 student 접두어를 갖고 학생 10 명의 정보를 담는 개의 배열

    char* student_first_names[10];
    char* student_surnames[10];
    int student_ages[10];
    double student_marks[10];
  

  • student 라는 동일한 개념으로 변수 여러개를 그룹으로 묶는 법

• 코드 박스 6-2 학생 10 명의 정보를 을 임시 이름을 갖는 개의 배열

    char* aaa[l0]; 
    char* bbb[l0]; 
    int ccc[10]; 
    double ddd[10];
  

💡 개념이란 사고 thought 또는 생각 idea으로, 마음속에 존재하는 정신적 또는 추상적 이미지입니다. 
개념 concept 은 현실 세계의 개체 entity 에 관한 인식으로 형성되거나, 단순하게는 완전히 가상적 imaginary이며 추상적 abstract 일 수 있습니다.

• 객체지향적 사고는 개념과 개념 사이 관계의 관점에서 사고하는 것
• 서로 연관된 객체 및 그에 대응하는 개념과 관계를 제대로 이해

6.1.2 마인드맵과 객체 모델

• 이해 단계 undstanding phase
• 작성하는 프로그램은 마음속 개념과 그 관계를 모방 simulate.
• 객체의 측면에서 개념을 모방
• 인간과 객체지향 프로그램을 비교하면 개념, 마음(mind), 마인드맵과 같은 용어는 객체, 메모리, 객체 모델에 각각 대응

6.1.3 코드에는 없는 객체

• 개념이 살아있는 마음속에만 존재할 수 있는 것처럼, 객체는 오직 실행 중인 프로그램에만 존재
• OOP 는 객체를 실제로 만들지 않습니다. OOP는 프로그램이 실행될 때 완전히 동적인 객체모델로 이어질 일련의 명령어를 만듭니다.
• 아직 만들어지지 않은 것에 관한 다양한 세부 사항을 설명하고 제작하는 기술을 일반적으로 설계design - CLASS
• 모든 객체는 지정된 생명 주기 lifecycle
• 불변 객체 immutable object로 가득한데, 불변 객체는 함수형 프로그래밍functionaI progranuning 패러다임

6.1.4 객체속성

• 객체는 두 개 이상의 속성 또는 속성의 집합을 가질 수 있다.
• 속성에 할당된 값을 총괄해 객체의 상태 state
• 객체는 수명 life time 동안 수정될 수 있습니다. 이런 객체를 가변 (mutable 객체)
• 객체는 불변 immutable 일 수도 있다. 이는 정확히, 변경할 수 없는 숫자 2에 해당하는 개념

💡 NOTE_ 상태가 없는 객체는 수명 동안 상태를 변경할 수 없으므로 불변 객체로 간주 한다.

6.1.5 도메인

• 도메인은 소프트웨어가 기능을 공개할 경계를 정의
• 소프트웨어가 다루어야 하는 요구 사항을 정의
• 도메인은 미리 정의된 구체적인 용어집 terminology(gIossary) 을 사용해 임무를 수행하고 엔지니어가 도메인의 경계 내에 있도록 합니다.
• 은행 도메인, 의료도메인, 헬스케어 도메인

6.1.6 객체 사이의 관계

• 객체는 관계를 나타내고자 서로를 참조
• 시스템 내의 모든 객체는 서로를 참조해 객체 모델이라는 객체의 네트워크를 형성
• 두 객체가 연관될 때 하나의 상태가 변하면 다른 상태에도 영향

{x: 53, y: 345, red: 120, green: 45, blue: 178, adjacent_down_pixel:p2}
{x: 53: y: 346, red: 79, green: 162, blue: 23, adj acent_up_pixel : p1}

6.1.7 객체 지향 작업

• 객체의 생성, 객체의 소멸 객체의 상태 변경

💡 NOTE_ 생성construction이라는 용어는 신중하게 사용해야 한다.

생성을 나타내는 용어로 creation 이나 building을 사용할 도 있지만. 이 단어는 OOP 관련 문헌에서 표준 용어로 받아 드려지지 않습니다.

creation은 객체의 메모리 할당을 뜻하고 construction은 속성의 초기화를 의미합니다. >

• 객체의 생성 계획하는 방법
  • 첫 번째 접근법은 빈 객체를 생성하거나 또는 더 일반적으로 최소 한의 속성의 집합을 갖는 객체를 생성하는 것
  • 코드가 실행되는 동안 더 많은 속성이 결정되고 추가 이 방식을 사용하면 주변 환경에서 발견되는 변경 사항에 따라 같은 프로그램을 다르게 두 번 실행할 때 같은 객체라도 다른 속성을 가질 수 있습니다.
  • 각각의 객체는 별도의 개체entity로 취급됩니다. 그리고 어떤 두 객체가 공통 속성의 목록을 가져서 같은 그룹(혹은 클래스에 속하는 것처럼 보이더라도 이들 두 객체는 프로그램이 지속되는 동안 상태에 다른 속성을 갖습니다.

  ---

  • 두 번째 접근법은 속성이 미리 정해져 있어서 실행 도중에 변경되지 않는 객체를 생성하는 것입니다. 이 객체는 런타임 동안 어떠한 속성도 추가되지 못해 객체는 구조를 유지합니다. 속성값만 변경할 수 있으며 이는 객체가 가변적mutable일 때만 가능합니다.
  • 이 접근법을 적용하려면. 개발자는 런타임 때 객체에 존재해야 하는 모든 속성을 추적하는 미리 설계된 객체 템플릿 또는 클래스를 만들어야 합니다. 그런 이 템플릿을 컴파일해서 런타임 시에 객체지향 언어로 제공 • 많은 프로 래밍 언어에서 이러한 객체 템플릿을 클래스라고 합니다. 자바나 C++, 파이썬과 같은 프로그래밍 언어는 객체 템플릿을 나타내는 용어로 클래스를 사용 이 기술은 보통 클래스 기반의 OOP라고 알려졌습니다. 파이썬은 프로토타입 기반 및 클래스 기반의 OOP를 모두 지원한다는 점

💡 NOTE_ 클래스는 객체에 존재하는 속성의 목록을 결정할 뿐. 런타임 시 실제로 할당되는 값은 아닙니다.

• 객체와 인스턴스instance는 같은 것이며 서로 바꿔 사용할 수 있습니다.
• 참조 referece- 객체 또는 인스턴스라는 용어는 객체의 값이 메모리에 할당된 실제 위치를 참조하는 데 사용됩니다. 반면 참조는 객체를 참조하는 포인터와 같습니다. 그러므로 같은 객체를 참조하는 여러 참조가 있을 수 있습니다. 일반적으로 ???객체는 이름이 없지만 참조는 이름이 있습니다.

💡 NOTE_ 에서는 참조에 대응하는 문법으로 포인터가 있습니다. 스택 객체 및 힙 객체가 있습니다. 힙 객체는 이름이 없으며 이를 참조하기 위해 포인터를 사용합니다. 반면 스택 객체는 실제로 변수이며 따라서 이름이 있습니다.

• 클래스 및 프로토타입 기반의 두 접근법을 모두 사용할 수 있지만. C 그리고 특히 C++은 공식적으로 클래스 기반의 접근법을 지원하는 방식으로 설계되었습니다
• 인간은 우선 존재한 다음 삶의 경험으로부터 본질을 얻는다는 뜻
• 프로토타입 기반의 접근법에서는 객체는 비어 있는 채로 생성된 다음 런타임 동안 발달
• 객체 창조자로서 클래스를 준비한 다음, 프로그램은 클래스에 따라 객체를 만들기 시작합니다.
• 객체 모델에서 참조 무결성 referential integrity 을 잃습니다.

6.1.8 행위를 갖는 객체

• 모든 객체는 속성과 더불어 수행할 수 있는 기능에 관한 특정 목록
• 자동차 객체 - 속도, 방향
• 기능은 언제나 도메인의 요구사항을 따름

⭐ 6.2 C가 객체지향이 아닌 이유

• 인간은 객체지향적 방식으로 사고하지만 CPU는 절차지향적 기계 명령어를 실행
• 객체지향은 인간이 문제를 이해하는 방식이며 절차지향적 실행은 CPU 가 할 수 있는 일
• 고수준 로직을 저수준의 절차지향적 명령어로 변환하는 례이어가 필요

⭐ 6.3 캡슐화

• 속성과 기능을 객체라는 개체-entity에 넣는 작업
• 캡슐화란 객체를 나타내는 캡슐에 서로 연관된 것을 집어넣는다는 의미

6.3.1 속성캡슐화

• 캡슐화 하려면 항상 변수명을 사용해야 하고, 서로 다른 변수를 묶어서 같은 객 체 내에 그룹으로 두어야 합니다.

• 코드 박스 6-3 두 픽셀을 나타내는 여러 변수를 이름으로 그루핑하기

    int pixel_p1_x = 56; 
    int pixel_p1_y = 34; 
    int pixel_p1_red = 123; 
    int pixel_p1_green = 37; 
    int pixel_p1_blue = 127; 
      
    int pixel_p2_x = 212; 
    int pixel_p2_y = 994; 
    int pixel_p2_red = 127; 
    int pixel_p2_green = 127; 
    int pixel_p2_blue = 0;
  

  • 암묵적 implicit 객체인 pl과 p2 아래에서 변수를 그루핑할 때 변수명을 어떻게 사용
  • 암묵적이란, 개발자가 이 객체의 존재를 아는 유일한 사람이라는 뜻
  • 프로그래밍 언어는 이 객체에 대해 아무것도 모름
  • 명시적explicit 캡슐화를 제공하는 접근법
  • 명시적이란, 개발자와 프로그래밍 언어 둘 다 캡슐화, 캡슐(또는 객체 의 존재를 안다는 의미)
• 명시적 기능은 상속이나 다형성 같은 다른 객체지향적 기능으로 확장될 수 있습니다.
• C에서는 구조체가 캡슐화를 제공

• [코드 박스 6-4] pixel_t 구조체와 pixel_t 변수 2개를 선언하기

    typedef struct { 
    	int x, y; 
    	int red,	green, blue; 
    } pixel_t; 
      
    pixel_t p1, p2; 
      
    p1.x = 56; 
    p1.y = 34; 
    p1.red = 123; 
    p1.green = 37; 
    p1.blue = 127; 
      
    p2.x = 212; 
    p2.y = 994; 
    p2.red = 127; 
    p2.green = 127; 
    p2.blue = 0
  

  • 속성 캡슐화는 x, y, red, green, blue 속성을 새 자료형인 pixel_t 로 넣을 때 발생
  • 캡슐화는 언제나 새로운 자료형을 만듦
  • _t 접미어가 pixel 의 끝에 붙음 not mandatory
  • p1과 p2는 실행될 때 명시적 객체가 됨.
  • 구조체는 속성만 가지므로 구조체는 클래스의 대응물이 아님.
  • 속성attribute과 기능functional이 따로따로 존재하고 우리는 이 둘을 암묵적으로 코드에 연관 시킵니다.
  • 모든 클래스는 C에서 암묵적이며, 모든 클래스는 C의 함수 목록을 갖는 하나의 구조체에 해당???
  • 템플릿 (여기서는 pixel_t 구조체)에 기반한 객체를 생성. <→ 프로토타입
  • 이 템플릿은 객체가 생성될 때 미리 결정된 속성을 갖음
  • 객체 선언하는 동안 동시에 두 가지 일이 발생 먼저 객체에 메모리가 할당(만들기 creation). 속성은 기본값 default value을 사용해 초기화(생성 construction) .
  • 객체 내부의 속성에 접근할 때 점 ( .）을 사용 포인터에 저장된 주소를 통해 간접적으로 구조체 속성에 접근할 때는 화살표( → ) 를 사용

6.3.2 행위 캡슐화

• 메서드는 객체 내에 저장되는 로직 또는 기능을 나타내고자 사용하는 표준 용어
• 메서드는 C의 함수로 간주할 수 있으며 이름, 인자의 목록, 반환형
• 속성은 value 전달하며 메서드는 행위behavior를 전달함.

• [코드 박스 6-5] 자바스크립트 에서 client 객체 생성하기

    // 빈 객체 생성 
    var clientObj = {}; 
    // 속성 생성 
    clientObj.name = "John"; 
    clientObj.surname = "Doe" ; 
    //  
    clientObj.orderBankAccount = function () { 
    	• • • 
    } 
    • • • 
    // 메서 드 호출 
    clientObj.orderBankAccount();
  

  • 익명 함수anonymous function가 있는데, 익명 함수는 이름을 갖지 않으며 왼쪽에 있는 객체에 orderBankAccount 속성을 할당

• [코드 박스 6-6] C++에서 client 객체 생성하기

    class Client { 
    public: 
      
    	void orderBankAccount () { 
    		• • • 
    	} 
    	std::string name; 
    	std::string surname;
    };  
      	
    Client clientObj; 
    clientObj.name = "John"; 
    clientObj.surname = "Doe"; 
      
    clientObj.orderBankAccount();
  

💡 NOTE_ 일반적으로 C++에서 메서드는 멤버 member function. 속성은 데이터 멤버data member   

• 암묵적 캡슐화implicit capsulation
• C는 명시적인 행위 캡슐화를 제공하지 않으므로 암묵적으로 사용.
• 암묵적 캡슐화 기법
  • 객체의 속성을 저장하기 위해 C의 구조체를 이용합니다(명시적 속성 캡슐화). 이 구조체는 속성 구조체attribute structure라고 합니다.
  • 행위 캡슐화를 위해 C의 함수가 사용됩니다. 이 함수는 행위 함수behavior function 라고 합니다.
  • 구조체는 함수를 가질 수 없습니다. 그러므로 이 함수는 속성 구조체 바깥에 존재해야 합니다(암묵적행위캡슐화).
  • 행위 함수는 인자 중 하나로 반드시 구조체 포인터를 받아야 합니다(주로 첫 번째 인자 또는 마지막 인자)
  • 이 포인터는 객체의 속성 구조체를 가리킵니다. 행위 함수는 일반적으로 객체의 속성을 읽거나 수정해야하기때문입니다.
  • 행위 함수가 객체의 동일한 클래스에 서로 연관되었음을 나타내려면 적절한 이름이 있어야 합니다. 그러므로 암묵적 캡슐화 기법을 사용할 때는 꼭 명명 규착을 일관적으로 지켜야 합니다.
  • 일반적으로 속성 구조체의 선언이 있는 헤더 파일에서 행위 함수에 대해 선언합니다. 이 헤더 파일은 선언 헤더 declaration header라고 합니다.
  • 일반적으로 선언 헤더를 포함하는 하나 또는 여러 별도의 소스 파일에서 행위 함수를 정의합니다.
• 암묵적 캡슐화에는 클래스가 존재하지만 암묵적이며 개발자만 클래스를 알고 있다는 점을 명심하세요.

• [코드 박스 6-7] [예제 ] Car 클래스의 속성 구조체와 행위 함수의 선언 ExtremeC_examples_chapter6_1.h)

    #ifndef EXTREME_C_EXAMPLES_CHAPTER_6_1_H 
    #define EXTREME_C_EXAMPLES_CHAPTER_6_1_H
      
    // 이 구조체는 자동차 car ) 객체에 연관된 모든 속성을 갖습니다. 
    typedef struct { 
    char name [ 32];
    double speed; 
    double fuel; 
    } car_t; 
      
    // 이 함수 선언은 자동차 객체의 행위에 해당합니다. 
    void car_construct(car_t*, const char*); 
    void car_destruct(car_t*); 
    void car_accelerate(car_t*); 
    void car_brake (car_t*); 
    void car_refuel(car_t*, double); 
    #endif
  

  • 각각의 객체는 자신만의 고유한 속성 구조체 변수를 갖습니다.
  • 하지만 모든 객체는 같은 행위 함수를 공유합니다. 각각의 객체의 속성 구조체 형에서는 지정된 변수dedicated variable 를 만들어야 하지만, 행위 함수는 단 한 번 작성해 서로 다른 객체에서 호출합니다.
  • 준객체지향semi-object-0riented 코드를 작성한 유명 오픈 소스 프로 젝트 - libcurl

• [코드 박스 6-8] [예제 6-1 ] Car 클래스의 행위 함수에 관한 정의 ExtremeC_examples_chapter6_1.c)

    // File name: ExtremeC_examples_chapter6_1.c
    // Description: Definitions of the behavior functions
      
    #include <string.h>
      
    #include "ExtremeC_examples_chapter6_1.h"
      
    // Definitions of the above functions
    void car_construct(car_t* car, const char* name) {
      strcpy(car->name, name);
      car->speed = 0.0;
      car->fuel = 0.0;
    }
      
    void car_destruct(car_t* car) {
      // Nothing to do here!
    }
      
    void car_accelerate(car_t* car) {
      car->speed += 0.05;
      car->fuel -= 1.0;
      if (car->fuel < 0.0) {
        car->fuel = 0.0;
      }
    }
      
    void car_brake(car_t* car) {
      car->speed -= 0.07;
      if (car->speed < 0.0) {
        car->speed = 0.0;
      }
      car->fuel -= 2.0;
      if (car->fuel < 0.0) {
        car->fuel = 0.0;
      }
    }
      
    void car_refuel(car_t* car, double amount) {
      car->fuel = amount;
    }
  

  • 모든 함수는 car_t 포인터를 첫 번째 인자로 받습니다. 이로써 함수가 객체의 속성을 읽고 수정하도록 합니다. 만약 함수가 속성 구조체에 대한 포인터를 받지 못한다면, 객체의 행위를 나타내지 못하는 평범한 ordinary C 함수로 간주해야 합니다.
  • 행위 함수의 선언은 함수에 대응하는 속성 구조체의 선언에 이어서 시행한다는 점
  • 속성 구조체와 행위 함수의 연관성을 관리하는 유일한 담당자가 개발자이고, 유지 보수가 매우 쉬워야 하기 때문입니다. 이런 이유로 속성 구조체와 행위 함수의 집합을 서로 가까이, 대개는 같은 헤더 파일에 두면, 클래스의 전반적인 구조를 유지하는 데 도움이 되고 나중에 들여야할 수고를덜어줍니다.

  • [코드 박스 6-9 ][예제 6-1 ]의 main 함수(ExtremeC_examples_chapter6_1. main . c)

      // File name: ExtremeC_examples_chapter6_1_main.c
      // Description: Main function
            
      #include "ExtremeC_examples_chapter6_1.h"
            
      // Main function
      int main(int argc, char** argv) {
            
        // Create the object variable
        car_t car;
              
        // Construct the object
        car_construct(&car, "Renault");
              
        // Main algorithm
        car_refuel(&car, 1000.0);
        while (car.fuel > 0) {
          if (car.speed < 80) {
            car_accelerate(&car);
          } else {
            car_brake(&car);
          }
        }
              
        while (car.speed > 0) {
          car_brake(&car);
        }
              
        // Destruct the object
        car_destruct(&car);
              
        return 0;
      }
    

    • main 함수가 car의 속성에 접근할 수 있다는 점
    • 예를 들어 fuel과 speed 라는 속성은 공개public 속성에 관한 예시
    • 공개 속성은 행위 함수 이외의 함수 외부 코드가 접근
    • main 함수를 떠나 프로그램을 종료하기 전에 car 객체를 소멸
    • 객체가 할당한 리소스가 해제되어야 함
    • 힙 할당의 경우 소멸 단계는 의무이며 이는 메모리 누수 방지.

  • [코드 박스 6-10] [예제 6—2) C++에서 Car 클래스의 선언 ExtremeC_examples_chapter6_2.h )

      // File name: ExtremeC_examples_chapter6_2.h
      // Description: Declaration of the class Car
            
      #ifndef EXTREME_C_EXAMPLES_CHAPTER_6_2_H
      #define EXTREME_C_EXAMPLES_CHAPTER_6_2_H
             
      class Car {
      public:
        // Constructor
        Car(const char*);
        // Destructor
        ~Car();
            
        void Accelerate();
        void Brake();
        void Refuel(double);
            
        // Data Members (Attributes in C)
        char name[32];
        double speed;
        double fuel;
      };
            
      #endif
    

    • 이 코드의 주요 특징은 C++가 클래스를 이해한다는 사실
    • 코드는 명시적 캡슐화를 나타내며 속성과 함수를 둘 다 캡슐화
    • 게다가 C++는 생성자나 소멸자와 같은 더 객체지향적인 개념을 지원
    • 행위 함수에는 첫 번째 포인터 인자가 없습니다.

  • [코드 박스 6-11] [예제 6-2] C++에서 Car 클래스의 정의 ExtremeC_examples_chapter6_2.cpp)

      // File name: ExtremeC_examples_chapter6_2.cpp
      // Description: Definition of the member functions in the Car class
            
      #include <string.h>
            
      #include "ExtremeC_examples_chapter6_2.h"
            
      Car::Car(const char* name) {
        strcpy(this->name, name);
        this->speed = 0.0;
        this->fuel = 0.0;
      }
            
      Car::~Car() {
        // Nothing to do
      }
            
      void Car::Accelerate() {
        this->speed += 0.05;
        this->fuel -= 1.0;
        if (this->fuel < 0.0) {
          this->fuel = 0.0;
        }
      }
            
      void Car::Brake() {
        this->speed -= 0.07;
        if (this->speed < 0.0) {
          this->speed = 0.0;
        }
        this->fuel -= 2.0;
        if (this->fuel < 0.0) {
          this->fuel = 0.0;
        }
      }
            
      void Car::Refuel(double amount) {
        this->fuel = amount;
      }
    

    • C 코드의 car 포인터가 의 키워드인 this 포인터로 대체되었습니다. this라는 키워드는 단순히 현재 객체를 의미합니다.

  • [코드 박스 6-12] [예제 6-2] main 함수 (ExtremeC_examples_chapter6_2_main.cpp)

      // File name: ExtremeC_examples_chapter6_2_main.cpp
      // Description: Main function
            
      #include "ExtremeC_examples_chapter6_2.h"
            
      // Main function
      int main(int argc, char** argv) {
            
        Car car("Renault");
            
        // Main algorithm
        car.Refuel(1000.0);
        while (car.fuel > 0) {
          if (car.speed < 80) {
            car.Accelerate();
          } else {
            car.Brake();
          }
        }
            
        while (car.speed > 0) {
          car.Brake();
        }
            	
            
        // When leaving the function, the object `car` gets
        // desructed automatically.
        return 0;
      }
    

    • C++에서 쓴 것과 매우 비슷하지만 구조체 변수 대신 클래스 변수에 메모리가 할당
    • 파일을 이용해서 같이
    • car_accelerate(&car) 대신 car.Accelerate( ) 를 사용
    • car_refuel(&car, 1000.00) 대신 car.Refuel(1000.0) 을 사용
    • C++ 사이에는 객체 소멸에 관한 중요한 차이
    • C++에서 소멸자 함수는 객체가 스택 가장 위에 할당되어 스코프를 벗어나려 할 때마다 다른 스택 변수처럼 자동으로 호출
    • C++의 메모리 관리가 이룩한 큰 성과
    • C에서는 소멸자 함수를 호출하는 것을 잊기 쉬워서 결국 메모리 누수가 발생

6.3.3 정보은닉

• 캡슐화의 또 다른 목적 또는 결과는 바로 정보 은닉 infomation-hiding
• 정보 은닉은 외부 세계에 보이지 않아야 하는 어떠한 속성이나 행위를 보호하는(또는 숨기는) 역할
• Car 클래스에서 car1이나 car2처럼 같은 자료형인 두 객체의 행위는 같은 자료형의 모든 객체의 속성에 접근
• 클래스의 모든 객체에 대해 행위 함수는 단 한 번만 작성
• 예제에서 main 함수는 car_t 속성 구조체의 speed와 fuel 속성에 쉽게 접근
• car_t 자료형의 모든 속성이 공개 public 속성
• 공개 속성 또는 행위를 갖는 건 바람직하지 못함.

• 구현 implemantation의 세부 사항이 유출

• 예) 자동차를 가속한다는 행위
  • 어떻게 가속할 수 있는지는 별로 궁금x
  • 객체 내에는 가속 과정에 영향을 주는 더 많은 내부 속성
  • 사용자 로직에 이러한 속성이 보여야 할 마땅한 이유는 없습니다.
  • 엔진 스타터에 전달되는 전류는 속성 (전압=승용12V, 사용차=24V) 100A,
  • 객체 자신에게 비공개
  • 객체 내부의 특정 행위에도 적용
  • 연소실에 연료를 주입하는 일은 내부 행위
  • 실행의 세부 사항(자동차가 어떻게 작동하는지 )은 제조사마다 다르지만, 자동차를 가속할 수 있다는 행위는 모든 자동차 제조사가 제공
  • 자동차 가속할 수 있는 행위를 Car 클래스의 공개 APl public API 또는 공용 인터페이스public interface
  • 객체의 공개 속성과 행위에 의존적
  • 내부 속성을 공개 속성으로 선언해 유출한 뒤 비공개로 바꾸면 종속된 코드의 빌드 깨질 수 있다.
  • 하위 호환성 backward compatibility이 손상
  • 보수적인 접근법- 속성을 공개로 두어야 할 합리적인 이유를 찾을 때까지 기본적으로 모든 속성을 비공개
  • 속성과 행위를 가능한 한 비공개
• 여러 정숫값을 저장하는 List 클래스에 관한 예제

  • [코드 박스 6-13] [예제 6-3] List 클래스의 공용 인터페이스 ExtreameC_examples_chapter6_3. h)

      // File name: ExtremeC_examples_chapter6_3.h
      // Description: The header file which exposes public attributes
      //              and behavior functions related to a list object.
      //              As you see, the attribute structure does not
      //              disclose any of its members.
            
      #ifndef EXTREME_C_EXAMPLES_CHAPTER_6_3_H
      #define EXTREME_C_EXAMPLES_CHAPTER_6_3_H
            
      #include <unistd.h>
            
      // The attribute structure with no disclosed attribute
      struct list_t;
            
      // Allocation function
      struct list_t* list_malloc();
            
      // Constructor and destructor functions
      void list_init(struct list_t*);
      void list_destroy(struct list_t*);
            
      // Public behavior functions
      int list_add(struct list_t*, int);
      int list_get(struct list_t*, int, int*);
      void list_clear(struct list_t*);
      size_t list_size(struct list_t*);
      void list_print(struct list_t*);
            
      #endif
    

    • 이 코드 박스는 속성을 비공개로 두는 방법을 보여줍니다. main 함수를 포함하는 파일처럼 다른 소스 파일이 위의 헤더를 포함하는 경우, list_t 자료형 내부의 속성에는 접근하지 못합니다. 이유는 간단합니다. list 는 정의가 없는 구조체 선언일 뿐이며 이 구조체의 필드에는 접근할 수 없습니다. list_t 로는 변수를 선언할 수도 없습니다. 이러한 방식으로 확실하게 정보를 은닉할 수 있습니다.
    • 다시 한번 말하자면 헤더 파일을 만들고 내보내기 전에 무언가를 공개로 둘지 아닐지를 반드시 이중 점검해야 합니다. 공개 행위 또는 공개 속성을 노출하면 객체를 소멸 시킬 때 종속성이 생깁니다.
    • 다음 [코드 박스6-14]는 list_t 속성 구조체의 실제 정의를 나타냅니다.
    • 헤더 파일이 아니라 소스 파일에서 정의되어야 한다는 점을 명심하세요.

  • [코드 박스 6-14] [예제 6-3] List 클래스의 정의 (ExtremeC_examples_chapter6_3.c)

      // File name: ExtremeC_examples_chapter6_3.c
      // Description: This file contains the actual definition of
      //              the `list_t` attribute structure. It also
      //              contains the implementations of the behavior
      //              functions exposed by the header file. It has
      //              also a private behavior functions which is
      //              used internally.
            
      #include <stdio.h>
      #include <stdlib.h>
            
      #define MAX_SIZE 10
            
      // Define the alias type bool_t
      typedef int bool_t;
            
      // Define the type list_t
      typedef struct {
        size_t size;
        int* items;
      } list_t;
            
      // A private behavior which checks if list is full
      bool_t __list_is_full(list_t* list) {
        return (list->size == MAX_SIZE);
      }
            
      // Another private behavior which checks the index
      bool_t __check_index(list_t* list, const int index) {
        return (index >= 0 && index <= list->size);
      }
            
      // Allocates memory for a list object
      list_t* list_malloc() {
        return (list_t*)malloc(sizeof(list_t));
      }
            
      // Constructor of a list object
      void list_init(list_t* list) {
        list->size = 0;
        // Allocates from the heap memory
        list->items = (int*)malloc(MAX_SIZE * sizeof(int));
      }
            
      // Destructor of a list object
      void list_destroy(list_t* list) {
        // Deallocates the allocated memory
        free(list->items);
      }
            
      int list_add(list_t* list, const int item) {
        // The usage of the private behavior
        if (__list_is_full(list)) {
          return -1;
        }
        list->items[list->size++] = item;
        return 0;
      }
            
      int list_get(list_t* list, const int index, int* result) {
        if (__check_index(list, index)) {
          *result = list->items[index];
          return 0;
        }
        return -1;
      }
            
      void list_clear(list_t* list) {
        list->size = 0;
      }
            
      size_t list_size(list_t* list) {
        return list->size;
      }
            
      void list_print(list_t* list) {
        printf("[");
        for (size_t i = 0; i < list->size; i++) {
          printf("%d ", list->items[i]);
        }
        printf("]\n");
      }
    

    • 이 코드 박스에서 모든 정의는 비공개입니다. list_t 객체를 사용할 외부 로직은 코드의 실행에 대해서는 아무것도 모릅니다.
    • 헤더 파일이 외부코드가 의존할 유일한 코드입니다. 이 파일은 심지어 헤더 파일조차 포함하지 않습니다. 정의와 함수 시그니처 헤더 파일의 선언과 일치하기만 하면 됩니다. 그렇기는 해도 선언 및 그에 해당하는 정의 사이의 호환성을 보장하므로 이렇게 작성하기를 권장합니다.
    • 사실 링커는 비공개 정의를 공개 선언으로 가져와서 작업 프로그램을 만듭다.
    • NOTE_ 비공개 행위 함수에 다른 표현법을 사용할 수 있습니다. 이름에 두어 __를 사용하는 방법입니다. 예를 들렴 __ check_index 는 비공개 함수입니다. 비공개 함수에 대한 선언 부분분은 헤더에 없으니 주의하세요.
  • main 함수는 리스트 객체 두 개를 만들며
  • 첫 번째 리스트 객체의 정보를 입력하고,
  • 두 번째 리스트를 사용해 첫 번째 리스트를 뒤집어서 저장
  • 마지막으로는 리스트 객체의 내용을 출력

  • [코드 박스 6-15 ][예제 6-3 main함수 ExtreameC_examples_chapter6_3_main.c)

      // File name: ExtremeC_examples_chapter6_3_main.c
      // Description: Contains the main function. The logics in
      //              this file are only dependent on the
      //              declarations made in the header file.
            
      #include <stdlib.h>
            
      #include "ExtremeC_examples_chapter6_3.h"
            
      int reverse(struct list_t* source, struct list_t* dest) {
        list_clear(dest);
        for (size_t i = list_size(source) - 1; i >= 0 ; i--) {
          int item;
          if(list_get(source, i, &item)) {
            return -1;
          }
          list_add(dest, item);
        }
        return 0;
      }
            
      int main(int argc, char** argv) {
        struct list_t* list1 = list_malloc();
        struct list_t* list2 = list_malloc();
            
        // Construction
        list_init(list1);
        list_init(list2);
            
        list_add(list1, 4);
        list_add(list1, 6);
        list_add(list1, 1);
        list_add(list1, 5);
            
        list_add(list2, 9);
            
        reverse(list1, list2);
            
        list_print(list1);
        list_print(list2);
            
        // Destruction
        list_destroy(list1);
        list_destroy(list2);
            
        free(list1);
        free(list2);
        return 0;
      }
    

    • 이 코드 박스에서 main과 reverse 함수는 헤더 파일에서 선언한 내용만을 토대로 작성했습니다. 즉, 이들 함수는 List 클래스의 공개 API (또는 공용 인터페이스)만을 사용합니다. 이 공개 API는 속성 구조체 list_t 의 선언과 행위 함수에 관한 것입니다. 이는 종속성을 없애고 코드의 다른 부분으로부터 구현의 세부 사항을 은닉 하는 좋은 사례입니다.

    💡 NOTE_ 공개 API 를 사용하면 컴파일할 프로그램을 작성할 수는 있습니다. 
    하지만 비공개 분에 해당하는 객체 파일을 제공하지 않거나 함께 하지 않으면. 실제 작업 프로그램으로 변환할 수 없습니다.

• list_t 객체에 메모리를 할당하려면 list_malloc 함수가 필요합니다. 그리고 객체에서 할당했던 메모리를 해제하려면 free 함수를 사용합니다.
• 앞의 예제에서 malloc을 직접 사용할 수는 없습니다. main 함수 안에서 malloc을 사용할 때는 할당에 필요한 바이트의 숫자를 sizeof(list_t )로 전달해야 합니다. 하지만 불완전한 형식에는 sizeof를 사용할 수 없습니다.
• 헤더 파일에서 포함하는 list_t 자료형은 불완전한 형식 incomplete type 입니다. 내부 필드에 아무 정보도 제공하지 않는 단순한 선언일 뿐이고, 컴파일할 때 이 자료형의 크기를 모르기 때문입니다.
• 실제 크기는 구현의 세부 사항을 알게 되는 링크 시에만 결정됩니다. 이를 해결하기 위해 list_malloc을 정의해 sizeof(list_t) 가 결정되는 곳에 malloc을 사용해야 했습니다.

• 셸박스 6-1 [예제 6-3] 컴파일하기

    $ gee - e ExtremeC_examples_ehapter6_3.e -o private.o 
    $ gee -e ExtremeC_examples_ehapter6_3_main.e -o main.o
  

• 비공개 부분은 private로 컴파일했으며 main 함수는 main.o 로 컴파일했습니다. 헤더파일은 컴파일하지 않는다는 점을 기억하세요. 헤더 파일의 공개 선언은 main.a 목적 파일에 포함되었습니다.
• 이제 이 목적 파일을 모두 링크 해야 합니다. 그렇지 않으면 main.o 하나만으로는 실행 가능한 프로그램이 될 수 없습니다. main.o 만으로 실행 가능한 파일을 만들려고 하면 다음과 같은 오류가 생깁니다.

• 셸 박스 6-2 main.o 만으로 [예제 6-3] 링크하기

    $ **gcc main.o -o ex6_3.out** 
    main . o : In function ' reverse ' : 
    ExtremeC_examples_ehapter6_3_main . e:( .text+0x27): undefined 
    referenee to 'list_clear' 
    • • • 
    main .o: In function 'main': 
    ExtremeC_examples_chapter6_3_main . c:( .text+0xaS): undefined 
    reference to 'list_malloc' 
    • • • 
    collect2: error: ld returned 1 exit status 
    $
  

• 링커가 헤더 파일에 선언된 함수의 정의를 찾을 수 없다고 합니다. 예제를 링크하는 알맞은 방법은 다음과 같습니다.

• 셸 박스 6-3 예제 6-3 링크하고 실행하기

    $ gcc main.o private.o -o ex6_3.out
    $ ./ex6_3.out
    [4 6 1 5 ]
    [5 1 6 4 ]
    $
  

• List 클래스 다음에 나오는 구현을 변경한다면 무슨 일이 발생할까요? 배열을 사용하는 대신 연결 리스트를 사용한다고 해봅시다. main.o를 다시 만들 필요는 없어 보입니다. main.o가 사용하는 리스트 구현 내용과 독립적이기 때문입니다. 따라서 private2.o 처럼 새로운 구현에 관한 새로운 객체 파일만을 컴파일하고 생성해봅시다. 그런 다음 목적 파일을 다시 링크해 새로운 실행 파일을 만들어봅니다.

• 셸박 스 6-4 List 의 다른 구현을 사용해 [예제 6-3] 링크하고 실행하기

    $ gcc main.o private2.o -o ex6_3.out
    $ ./ ex6_3.out
    [4 6 1 5 ]
    [5 1 6 4 ]
    $
  

• 사용자 관점에서는 아무것도 변하지 않았습니다. 하지만 근본적인 구현은 바뀌었습니다. 이는 대단한 성과이며 프로젝트에서 많이 사용되는접근법입니다.
• 새로운 리스트 구현에 관한 경우에서 링크 단계를 반복하고 싶지 않다면 어떻게 해야 할까요? 그때는 비공개 목적 파일을 포함하는 공유 러이브러리 (또는 . so 파일 )를 사용합니다. 그러면 런타임 시 동적으로 로드할 수 있으며 실행 파일을 다시 링크하지 않아도 됩니다.