데브웁스

• typeid
  • 타입에 대한 정보를 얻을때 사용하는 연산자
  • <typeinfo> 헤더 파일을 포함해야 함 // 컴파일러에 따라 생략 가능(표준 스팩은 명시 해야함)
  • typeid(타입)
  • typeid(객체)
  • typeid(expression)
  • typeid의 결과로 const std::type_info& 반환
  • 가상 함수가 없는 객체(non-polymorphic) : 컴파일 시간에 타입 조사
  • 가상 함수가 있는 객체(polymorphic) : 실행시간에 타입을 조사(가상함수 테이블 정보 참고)
• std::type_info
  • 타입의 정보를 담고 있는 클래스
  • 사용자가 직접 객체 생성할 수 없고 typeid() 연산자를 통해서만 얻을 수 있음
  • 멤버 함수인 name()을 통해서 타입의 이름을 얻을 수 있음
  • 실행 결과는 컴파일러 마다 표현 바법이 다름
  • g++로 생성된 실행파일의 경우 "a.exe | c++filt -t"로 실행하면 완전한 타입의 이름을 볼수 있음
• RTTI(Run Time Type Information)
  • 실행 시간에 타입의 정보를 조사하는 기법
• std::type_info로 동일 타입 조사 방법
  • t1 == t2 : ok
  • t1.hash_code() == t2.hash_code() : ok
  • std::type_index(t1) == std::type_index(t2) : ok
  • &t1 == &t2 : not guaranteed

#include <iostream>
#include <typeinfo>
#include <typeindex>

class Animal 
{
public:
    virtual ~Animal() {}

};
class Dog : public Animal {};

void foo(Animal* p)
{
    const type_info& t1 = typeid(*p);
    const type_info& t2 = typeid(Dog);

    // 방법 1
    if (t1 == t2) // 실전 코드 : if( typeid(*p) == typeid(Dog))
    {
        std::cout << "p는 Dog" << std::endl;
    }
    // 방법 2
    if (t1.hash_code() == t2.hash_code())
    {

    }
    // 방법 3
    if (std::type_index(t1) == std::type_index(t2))
    {

    }

    std::cout << t1.name() << std::endl;
}

int main()
{
    Animal a; foo(&a);
    Dog d; foo(&d);
}

가상 함수의 원리

• 가상 함수가 1개 이상 포함 되어 있으면 컴파일러가 객체 주소에 가상 함수 테이블 포인터가 추가함
• 가상 함수 테이블은 Class 별로 생성되어 RTTI 정보를 포함한 모든 가상함수 주소를 제공
• 상속 받은 클래스의 가상 함수 테이블은 기본적으로 기반 클래스의 가진 가상 함수 주소를 가르키지만 파생 클래스에서 override하여 구현한 함수에 대해서는 구현한 가상함수의 주소를 가르킴
• 가상함수 갯수가 많으면 오버헤드가 있음

class Animal
{
    int age;
public:
    virtual ~Animal() {}
    virtual void foo() {}
    virtual void goo() {}
};

class Dog : public Animal
{
    int color;
public:
    virtual ~Dog() {}
    virtual void foo() override {}
};

int main()
{
    Animal a1, a2;
    Dog d1, d2;
    
    Animal* p = &d1;    
    p->foo(); // 내부적으로 p->vtptr[?]() 호출
}

static binding

• 컴파일러가 컴파일 시간에 함수 호출을 결정
• 포인터 타입으로 함수 호출을 결정
• 빠름, 하지만, 비 이성적임
• 이른 바인딩( Early Binding )
• C++의 non-virtual function

dynamic binding

• 실행 시간에 함수 호출을 결정
• 포인터가 가리키는 메모리를 조사후 결정
• 느림. 하지만, 이성적
• 늦은 바인딩( Late Binding )
• java, C++의 virtual function

// Static binding
class Animal
{
public:
    void Cry() { std::cout << "A Cry" << std::endl; }
};

class Dog : public Animal
{
public:
    void Cry() { std::cout << "D Cry" << std::endl; }
};

int main()
{
    Animal a;
    Dog d;

    Animal* p = &d;
    p->Cry();   // C++ : A
                // JAVA : D
}

// Dynamic binding
class Animal
{
public:
    virtual void Cry() { std::cout << "A Cry" << std::endl; }
};

class Dog : public Animal
{
public:
    virtual void Cry() override { std::cout << "D Cry" << std::endl; }
};

int main()
{
    Animal a;
    Dog d;

    Animal* p = &d;
    p->Cry();   // C++ : A
                // JAVA : D
}

• 강한 결합(Tightly coupling)
  • 하나의 클래스가 다른 클래스를 사용할 때 서로의 이름을 직접 사용하는 것
  • 교체 불가능하고 확장성이 없음

class Camera
{
public:
    void take()
    {
        std::cout << "task picture" << std::endl;
    }
};

class HDCamera
{
public:
    void take()
    {
        std::cout << "task picture" << std::endl;
    }
};

class People
{
public:
    void useCamera(Camera* p) { p->take(); } // People이 Camera를 직접 접근
    void useCamera(HDCamera* p) { p->take(); } // People이 HDCamera를 직접 접근
};

int main()
{
    People p;
    Camera c1;
    p.useCamera(&c1);

    HDCamera c2;
    p.useCamera(&c2);
}

약한 결합(Loosely coupling)

• 하나의 클래스가 다른 클래스를 사용할 때 인터페이스(추상 클래스)를 사용하는 것
• 교체 가능하고, 확장성이 높음

// 사람과 카메라사이의 규칙 설계
// 모든 카메라는 ICamera 인터페이스를 구현 해야 함
class ICamera
{
public:
    virtual void take() = 0;
};

class People
{
public:
    void useCamera(ICamera* p) { p->take(); } // People이 공통 인터페이스(ICamera)로 접근
};

// 모든 카메라는 규칙을 지켜야 한다
class Camera : public ICamera
{
public:
    virtual void take() override
    {
        std::cout << "task picture1" << std::endl;
    }
};

class HDCamera : public ICamera
{
public:
    virtual void take() override
    {
        std::cout << "task picture2" << std::endl;
    }
};

int main()
{
    People p;
    Camera c1;
    p.useCamera(&c1);

    HDCamera c2;
    p.useCamera(&c2);
}

추상 클래스(Abstract Class)

• 순수 가상 함수(Pure Virtual Function)
  • 함수 구현부가 없고 선언부가 "=0"으로 끝나는 가상함수
• 추상 클래스(Abstract Class)
  • 순수 가상 함수가 한개 이상 있는 클래스
• 추상 클래스 특징
  • 객체를 만들 수 없음
  • 포인터 타입은 만들 수 있음
• 추상클래스로 부터 상속 받은 클래스가 순수 가상함수의 구현부를 제공하지 않으면 추상 클래스
• 추상 클래스의 의도
  • 파생 클래스에게 특정 함수를 반드시 구현을 지시하는 것
  • 인터페이스

#include <iostream>
#include <vector>

// 추상 클래스
class Shape
{
public:
    virtual void Draw() = 0; // 순수 가상함수
};

// 구체 클래스(concerect class)
class Rect : public Shape
{
public:
    virtual void Draw() override
    {

    }
};

int main()
{
    Shape* p; // 추상클래스 포인트는 만들 수 있음
    Rect r; // 추상 클래스를 상속받은 클래스에서 순수 가상함수를 구현하지 않으면 error
}

도형편집기로 배우는 객체지향 프로그래밍

• 각 도형을 타입으로 만들면 편함
• 모든 도형 공통의 기반 클래스가 있으면 각 도형을 묶어서 관리 할 수 있음
• 모든 도형의 공통의 특징(Draw)는 반드시 기반 클래스(Shape)에도 있어야 함
• 기반 클래스의 함수 중 파생 클래스가 재정의 하게 되는 모든 함수는 가상함수가 되어야 함

다형성(Polymorphism)

• 동일한 코드 표현(함수 호출)이 상황에 따라 다르게 동작하는 것
• OCP(Open Close Principle)
  • 기능 확장에는 열려(Open) 있고 코드 수정에는 닫혀(Close) 있어야 한다는 이론(Principle)
  • 다형성은 OCP를 만족할 수 있는 좋은 코드

#include <iostream>
#include <vector>

// 도형
class Shape
{
public:
    virtual void Draw()
    {
        std::cout << "Shape Draw" << std::endl;
    }
};

// 사각형
class Rect : public Shape
{
public:
    virtual void Draw() override
    {
        std::cout << "Rect Draw" << std::endl;
    }
};

// 원
class Circle : public Shape
{
public:
    virtual void Draw() override
    {
        std::cout << "Circle Draw" << std::endl;
    }
};

// 삼각형
class triangle : public Shape
{
public:
    virtual void Draw() override
    {
        std::cout << "Circle Draw" << std::endl;
    }
};

int main()
{
    std::vector<Shape*> v1; // 도형 저장 버퍼

    while (1)
    {
        int n;
        std::cin >> n;

        if (n == 1) v1.push_back(new Rect); // 사용자 입력이 1일때 사각형 추가
        else if (n == 2) v1.push_back(new Circle); // 사용자 입력이 2일때 원형 추가
        else if (n == 9) // 사용자 입력이 9일때 추가된 도형 전체 출력
        {
            for (int i = 0; i < v1.size(); i++)
                v1[i]->Draw(); // 다형성(Polymorphism) 특징
        }
    }
}

오버라이드

• function override
  • 기반 클래스의 함수를 파생 클래스에서 재정의 할 수 있음
• 기반 클래스의 포인터로 파생 클래스 객체를 가르킬때(Animal* p = &dog)
  • p->Cry() : C++은 Animal::Cry() 호출, java는 Dog::Cry()  호출
• virtual function
  • 멤버 함수 호출시, 포인터 타입이 아닌 실제 객체에 따라 함수를 호출
  • 실행 시간에 포인터가 가리키는 메모리를 조사한 후 호출 하는것

// 기본 타입 예제
#include <iostream>
#include <vector>

class Animal
{
public:
    void Cry()
    {
        std::cout << "Animal Cry" << std::endl;
    }
};

class Dog : public Animal
{
public:
    // 함수 오버라이드(override)
    void Cry()
    {
        std::cout << "Dog Cry" << std::endl;
    }
};
int main()
{
    Animal a; a.Cry(); // Animal::Cry() 호출
    Dog d; d.Cry(); // Dog::Cry() 호출

    Animal* p = &d;
    p->Cry(); // Animal::Cry() 호출,  C++에서는 포인터 메모리 타입의 함수를 호출함
}

/////////////////////////////////////////////////////////////

// 가상 함수 변경 예저
#include <iostream>
#include <vector>

class Animal
{
public:
    // 가상 함수
    virtual void Cry()
    {
        std::cout << "Animal Cry" << std::endl;
    }
};

class Dog : public Animal
{
public:
    // 함수 오버라이드(override)
    virtual void Cry()
    {
        std::cout << "Dog Cry" << std::endl;
    }
};
int main()
{
    Animal a; a.Cry(); // Animal::Cry() 호출
    Dog d; d.Cry(); // Dog::Cry() 호출

    Animal* p = &d;
    p->Cry(); // Dog::Cry() 호출, 가상 함수이므로 객체에 따라 함수 호출
}

virtual function

• 가상 함수 재정의(override)시에는 virtual 키워드는 붙여도 되고 붙이지 않아도 됨
• 가상 함수 재정의시 실수를 막기 위해서 override 키워드를 사용(C++11)
• 가상 함수를 선언과 구현으로 분리 할때는 선언부에만 virtual, override을 표기

#include <iostream>
#include <vector>

class Animal
{
public:
    virtual void Cry()
    {
        std::cout << "Animal Cry" << std::endl;
    }
};

class Dog : public Animal
{
public:
    // 함수 오버라이드(override)
    virtual void Cry() override // virtual, override를 제거해도 빌드 되지만 실수 방지용
    {
        std::cout << "Dog Cry" << std::endl;
    }
};
int main()
{
    Animal a; a.Cry();
    Dog d; d.Cry();

    Animal* p = &d;
    p->Cry();
}

virtual destructor

• Upcasting사용시 기반 클래스의 소멸자는 반드시 가상 소멸자여야 함

class Base
{
public:
    Base() { std::cout << "Base 자원 할당" << std::endl; }
    virtual ~Base() { std::cout << "Base 자원 해지" << std::endl;  }
};

class Derived : public Base
{
public:
    Derived()
    {
        std::cout << "Derived 자원 할당" << std::endl;
    }
    virtual ~Derived()
    {
        std::cout << "Derived 자원 해지" << std::endl;
    }
};

int main()
{
    Derived* p = new Derived;
    delete p;
}

Upcasting #1

• 기반 클래스의 포인터로 파생 클래스를 가리킬 수는 있지만 파생 클래스의 고유한 멤버에 접근은 불가
• 파생 클래스의 고유 멤버에 접근 하려면 기반 클래스 포인터를 파생 클래스의 포인터 타입으로 캐스팅 해야함

#include <iostream>
#include <string>

class Animal
{
public:
    int age;
    std::string name;
};

class Dog : public Animal
{
public:
    int color;
    int getColor() const { return color; }
};

int main()
{
    Dog dog; // 객체의 포인터 크기, 32bit : 4byte, // 64bit : 64bit

    //int* p = &dog; // error, 서로다른 타입, reinterpret_cast
    Animal* p = &dog; // ok.. 기반 클래스가 -> 파생 클래스를 가르키는 방법
    p->age = 20; // 기반 클래스 멤버
    p->name = "AA"; // 기반 클래스 멤버
    p->color = 1; // 파생 클래스 멤버(error)
    p->getColor(); // 파생 클래스 멤버(error)
    static_cast<Dog*>(p)->color = 10; // 파생 클래스 멤버에 접근을 위해서는 static_cast 필요
}

Upcasting #2

• 동종(동일한 기반 클래스를 사용하는 클래스)을 처리하는 함수를 만들 수 있음

#include <iostream>
#include <string>

class Animal
{
public:
    int age;
};

class Cat : public Animal {};
class Dog : public Animal {};

void HappyNewYear(Animal* p) // Upcasting이 없으면 Cat*, Dog*... 등의 각 동물별 함수 필요
{
    ++(p->age);
}

int main()
{
    Dog dog;
    HappyNewYear(&dog);

    Cat cat;
    HappyNewYear(&cat);
}

• 동종을 보관하는 컨테이너를 만들 수 있음

#include <vector>

class Animal
{
public:
    int age;
};

class Cat : public Animal {};
class Dog : public Animal {};

int main()
{
    std::vector<Dog*> v1; // Dog만 보관
    std::vector<Cat*> v2; // Cat만 보관
    std::vector<Animal*> v3; // 모든 동물 보관
}

예제(Composite 패턴)

• 윈도우 탐색기
  • Folder는 File, Folder를 함께 보관
    • File, Folder는 공통의 기반 클래스가 필요
      
      • folder : item
      • file : item
    • A, B를 함께 보관하고 싶다면 공통의 기반 클래스가 필요
• 파워포인트
  • Component
    • Group : Component
    • Shape : Component
      • Rect : Shape
      • Circle : Shape