대바보의 끄적끄적

Inheritance (is-a relationship)

상속이 도움되는 이유를 구체적인 사례를 보자.

학생,교수 클래스 모두 이름이 있다.
학생,교수의 공통점은 사람이다.

사람의 기본적인 데이터(이름)를 부모클래스로 생성한다.
즉, 중복되는 데이터만 부모클래스로 뽑아낸다.

부모클래스만 사용하는기능은 부모클래스에 정의한다.
set,get등이 있다.

부모클래스의 기능을 사용가능한건 this로 확인할 수 있다.

중복되는 기능을 유지보수할때 부모클래스만 수정하면되게된다.

아래코드는 교수,학생클래스를 생성할때 공통된 데이터인

이름을 부모클래스로 생성해 상속받는다.

Person.h

#pragma once
#include <string>
#include <iostream>

class Person 
{
private:
	std::string m_name;

public:
	Person(const std::string & name) 
	:m_name(name) {}

	void setName(const std::string & name) {
		m_name = name;
	}

	std::string getName() const{
		return m_name;
	}

	void doNothing() const
	{
		std::cout << m_name << " doNothing" << std::endl;
	}
};

Student.h

#pragma once

#include "Person.h"

class Student : public Person{
private:
	int m_intel;

public:
	Student(const std::string & name = "noName", const int & intel = 0)
		: Person(name), m_intel(intel) {}

	void setIntel(const int & intel) {
		m_intel = intel;
	}

	int getIntel()
	{
		return m_intel;
	}

	friend std::ostream & operator << (std::ostream & out, const Student & s) {
		out << s.getName() << " " << s.m_intel;
		return out;
	}
};

Teacher.h

#pragma once

#include "Person.h"

class Teacher :public Person
{
private:


public:
	Teacher(const std::string & name = "noName")
		:Person(name) {

	}

	friend std::ostream & operator << (std::ostream & out, const Teacher & t1) {
		out << t1.getName();
		return out;
	}

};

main.cpp

#include "Student.h"
#include "Teacher.h"

using namespace std;

int main()
{
	string name = "";
	Student s("Jack Jack");
	Teacher t("Choi");

	cout << s.getName() << endl;
	cout << t.getName() << endl;

	s.doNothing();
	t.doNothing();

	return 0;
}

객체지향의 핵심
is-a relationship
inheritance

자식클래스는 상속받은 부모클래스의 기능을 모두 사용할 수 있다.
상속을 받은 클래스(자식클래스)를 derived class라고도 한다.

여러클래스에 일반화된것들을 뽑아서 부모클래스로 생성한다.
즉, 여러클래스에서 재사용이 매우용이하다.

부모클래스,자식클래스에 이름이 같은 메소드가 있다면 자식클래스의 메소드가 실행된다.
private는 자식에게도 허용이안된다. 이럴때 protected를 사용거나 부모클래스 생성자를 사용한다.

자식클래스의 생성이유는 부모클래스의 기능과 자식클래스의 기능을 합쳐쓰기 위함이다.

자식클래스에서 생성자Constructor를 만들려면 부모클래스를 불러와 정의해준다.

당연히 자식클래스에서 부모클래스를 사용할수 있기 때문에

부모클래스가 먼저생성되고 자식클래스가 생성된다. 

즉, 자식클래스가 생성될때 부모클래스의 생성자를 같이 실행한다.

즉, 기본생성자가 없으면 정의 해주어야한다.
아니면 자식클래스 생성자에서 부모클래스생성자를 선언해준다.

#include <iostream>

using namespace std;

class Mother {
private:
	int m_i;

public:
	//Mother(){}

	Mother(const int & i_in) 
	: m_i(i_in) {
		cout << "constructor" << endl;
	}

	void setValue(const int & i) {
		m_i = i;
	}

	int getValue() {
		return m_i;
	}
};

class Child : public Mother
{
private:
	double m_d;

public:
	Child(const double & d_in, const int & i_in) 
	: Mother(i_in),m_d(d_in)
	{}

	void setValue(const double & d_in,const int & i_in) {
		Mother::setValue(i_in);
	}

	void setValue(const double & d) {
		m_d = d;
	}

	double getValue() {
		return m_d;
	}
};

//Mother 클래스 재사용
class Daughter : public Mother
{

};

int main()
{
	Mother mother(11);
	mother.setValue(1234);
	cout << mother.getValue() << endl;

	Child child(12,222);
	cout << child.getValue() << endl;
	cout << child.Mother::getValue() << endl;

	return 0;
}