클래스와 객체지향 프로그래밍

클래스와 객체 → 접근 지정자 (public / protected / private)
        ↓
생성자 · 멤버 초기화 목록 · 소멸자 → 호출 순서
        ↓
복사 생성자와 얕은 / 깊은 복사 → const 멤버 함수
        ↓
상속 → 상속 종류별 접근 표 → 오버라이딩과 가리기
        ↓
virtual과 다형성 → 가상 소멸자 → 추상 클래스

class Student {               // 설계도 (새 자료형)
public:
    int number;
    char name[20];
 
    void print() const {      // 멤버 함수(메서드)
        cout << number << ' ' << name << '\n';
    }
};                            // 세미콜론 필수
 
Student s;                    // 객체
s.number = 1;                 // 점 연산자로 멤버 접근
Student* p = &s;
p->print();                   // 포인터는 -> 사용 ((*p).print()와 같음)

class A {
public:    int x; A* pa;
protected: int y;
private:   int z;
};
class B : public A { public: A objA; };
class C : public B { public: C* pc; B objB; };

class P {
    int x;
public:
    P(int v) : x(v) {}
};
P a;          // 컴파일 오류: P() 없음
P b(3);       // OK

class Player {
    string name;
    int hp;
    const int id;          // const 멤버와 참조 멤버는 초기화 목록에서만 초기화 가능
public:
    Player(string n, int h, int i) : name(n), hp(h), id(i) {}
};

생성: 기반 클래스 → 멤버 객체(선언 순서) → 자기 생성자 본문
소멸: 정확히 반대  (자기 소멸자 본문 → 멤버(선언 역순) → 기반)

class Box {
public:
    int* v;
    Box(int x) { v = new int(x); }
    Box(const Box& o) { v = new int(*o.v); }   // 깊은 복사: 새 메모리에 값 복사
    ~Box() { delete v; }
};

class Cnt {
    int v;
public:
    Cnt(int x = 0) : v(x) {}
    int get() const { return v; }   // OK: 읽기만
    void inc() { v++; }
};
const Cnt k(5);
k.get();      // OK
k.inc();      // 컴파일 오류

class Animal {
protected:
    int id;
public:
    Animal() : id(0) { cout << "Animal() "; }
    ~Animal() { cout << "~Animal() "; }
    int getId() const { return id; }
    void setId(int v) { id = v; }
};
 
class Mouse : public Animal {         // public 상속
public:
    Mouse() { cout << "Mouse() "; }   // Animal()이 먼저 자동 호출
    ~Mouse() { cout << "~Mouse() "; }
    void print() const { cout << "id=" << id << ' '; }   // protected라서 접근 가능
};

class H  { public: void f(); void f(int); };
class HD : public H { public: void f(int); };   // H의 f()와 f(int)를 모두 가림
 
HD d;
d.f(1);       // HD::f(int)
d.f();        // 컴파일 오류: H::f()가 가려짐
d.H::f();     // OK: 기반 이름을 직접 지정

NB* p = new ND; delete p;   // 소멸자가 virtual 아님 → 보통 "~NB"만 출력
VB* q = new VD; delete q;   // virtual ~VB() → "~VD ~VB"