05. 상속과 포함

 

 - 상속과 포함

// - 상속 (is a kind of, is a)
// 말그대로 부모 클래스의 모든 멤버를 물려 받은 것 + 새로운 멤버를 추가 가능

// 파생 클래스
// class 파생클래스 : public: 부모클래스

// 다중상속 존재

// : - 상속을 나타냄 

// 포함 - 클래스 내부에 외부 클래스의 멤버가 있는 상황 (has a)

class AAA{
public:
   int a=10;
public:
  output(){ };
}
class CCC{
public:
   int c=30;
   AAA p;
public:
  output(){ cout<<p.a+b<<endl;;};
}


// 상속
class A {
public:
	int a = 10;
public:
	void output() { };
};

class B : public A {
public:
	int b = 30;
public:
	void output() { cout << a << ", " << b << endl;; };
};

 

class Vehicle {
	int serial;
protected:
	int speed;
public:
	int price;
	Vehicle(int s = 0) : serial(s), speed(0), price(0){}
	void speedUp() { speed++; }
	void speedDown() { speed--; }
	void print() 
	{
		cout << "[Vehicle] serial : " << serial << ", speed :" << speed << ", price : " << price << endl;
	}
};

class Car : public Vehicle {
	int gear;
public:
	Car(int g = 0) : gear(g) {}
	void pushAccel() { speed += 5; }
	void pushBrake() { speedDown(); }
	void setGear(int g) { gear = g; }
	void printCarInfo(const char* msg) {
		cout << msg << " speed :" << speed << ", price : " << price << ", gear : "<< gear << endl;
	}
};

int main()
{
	Car myCar(2), dreamCar(5);

	myCar.pushAccel();
	myCar.price = 3000;
	dreamCar.price = 10000;

	myCar.print();
	dreamCar.print();

	myCar.printCarInfo("[My Car]");
	dreamCar.printCarInfo("[Dream Car]");
}


// 멤버함수 중 상속되지 않은 함수 -> 생성자, 복사생성자, 대입 연산자, 소멸자

부모 클래스의 접근 지정자	private 상속	protected 상속	public 상속
private	자식에서 직접 접근 불가 private 멤버가 됨	자식에서 직접 접근 불가 private 멤버가 됨	자식에서 직접 접근 불가 private 멤버가 됨
protected	자식에서 직접 접근 가능 private 멤버가 변함	자식에서 직접 접근 가능 protected  멤버	자식에서 직접 접근 가능 protected 멤버
public	자식에서 직접 접근 가능 private 멤버가 변함	자식에서 직접 접근 가능 protected 멤버로 변함	자식에서 직접 접근 가능 public 멤버

 

 

 

- 오버라이딩(overriding)

// 오버라이딩
// 부모에게 정의된 멤버를 자식 클래스에서 재정의하는 것

// 멤버 변수의 재정의 X -> 객체에 동일한 의미의 변수가 여러 개 생길 수 있음

class A {
public:
	void overriding() { cout << "A 클래스의 over 함수 호출!" << endl; }
};

class B : public A {
public:
	void overriding() { cout << "B 클래스의 over 함수 호출!" << endl; }
};

int main()
{
	B b;
	b.overriding();
	return 0;
}

 

// 오버로딩
// - 오버라이드 하고자 하는 메서드가 상위 클래스에 존재
// - 메소드 이름이 같아야 함
// - 피라미터의 수와 그 피라미터의 자료형이 같아야 함
// - 리턴형도 같아야 함
// - 상위 메소드와 동일하거나 내용이 추가되어야 함


class Base {
private:
	string str;

public:
	Base(const string& _str) { str = _str; }
	void printStr() { cout << "기초클래스: " << str << endl; }
};

class Derived : public Base {
private:
	int num;

public:
	Derived(const string& _str, int _num) : Base(_str) { num = _num; }
	void printStr() { cout << "파생클래스: " << num << endl; }	// str 대신 num 출력하도록 오버라이딩
};

int main() {
	Base* ptr;
	Base a("base class");
	Derived b("derived class", 10);

	ptr = &a;
	ptr->printStr();
	ptr = &b;	// Derived는 Base를 상속받기 때문에 is-a 관계. 따라서 Base 객체 포인터는 Derived 객체를 가리킬 수 있음
	ptr->printStr();	// 이를 업 캐스팅(파생 클래스에서 기반 클래스로 캐스팅하는 것)이라한다.

	return 0;
}

// 자식 클래스에서 직접 오버라이딩 할 때의 문제점은 -> 포인터
// ptr은 base 클래스 타입의 포인터로 정의되어 있다.

// ptr이 가리키는 객체를 변경하더라도 컴파일러는 포인터 ptr이 가리키는 변수의 타입 기준으로 함수 호출
// 따라 자식이 아닌 부모 클래스가 호출됨 -> viraual 키워드 사용


class Base {
private:
	string str;

public:
	Base(const string& _str) { str = _str; }
	virtual void printStr() { cout << "기초클래스: " << str << endl; }
};

class Derived : public Base {
private:
	int num;

public:
	Derived(const string& _str, int _num) : Base(_str) { num = _num; }
	virtual void printStr() override { cout << "파생클래스: " << num << endl; }
	// 기초 클래스에서만 virtual 키워드를 사용해도 되지만, 이왕이면 파생 클래스에서도 
	// virtual 키워드를 사용해서 해당 함수가 가상함수임을 명확하게 드러내는 편이 좋다.
	// override 키워드 명시해 오버라이딩 함수라는 것을 의미할 수 있음
};

int main() {
	Base* ptr;
	Base a("base class");
	Derived b("derived class", 10);

	ptr = &a;
	ptr->printStr();
	ptr = &b;
	ptr->printStr();

	return 0;
}