C++ 프로그래밍 10 주차

# 상속

#include <iostream>
using std::cout;
class A { // 기본 클래스, 부모 클래스
private:
    void a1() { cout << "a1\n"; }
    void a2() { cout << "a2\n"; }
public:
    void b1() { cout << "b1\n"; }
    void b2() { cout << "b2\n"; }
    void b3() { cout << "b3\n"; }
    void b4() { cout << "b4\n";}
};
int main()
{
    A aa;
    aa.b1();

}

 

# 상속 없을 때

#include <iostream>
using std::cout;
class A { // 기본 클래스, 부모 클래스
private:
    void a1() { cout << "a1\n"; }
    void a2() { cout << "a2\n"; }
public:
    void b1() { cout << "b1\n"; }
    void b2() { cout << "b2\n"; }
    void b3() { cout << "b3\n"; }
    void b4() { cout << "b4\n";}
};
class B {
private:
    void a1() { cout << "a1\n"; }
    void a2() { cout << "a2\n"; }
public:
    void b1() { cout << "b1\n"; }
    void b2() { cout << "b2\n"; }
    void b3() { cout << "b3\n"; }
    void b4() { cout << "b4\n";}
};
int main()
{
    A aa;
    aa.b1();
    B bb;
    bb.
}

하나하나 코드를 적어서 사용해야 함

 

# 상속하는 법

#include <iostream>
using std::cout;
class A { // 기본 클래스, 부모 클래스
private:
    void a1() { cout << "a1\n"; }
    void a2() { cout << "a2\n"; }
public:
    void b1() { cout << "b1\n"; }
    void b2() { cout << "b2\n"; }
    void b3() { cout << "b3\n"; }
    void b4() { cout << "b4\n";}
};
class B : public A { // 상속
};
int main()
{
    A aa;
    aa.b1();
    B bb;
    bb.
}

상속을 받고 싶을 때 public 과 부모 클래스를 적으면 됨

모든 것이 상속이 되는 것이 아닌 부모 클래스의 public 만 상속이 된다.

 

# C++ 에서 상속하는 법

상속?

• 코드 재사용
• 기존 클래스의 속성과 메소드를 새 클래스에 전달
• 기본 클래스 또는 부모 클래스를 상속 받아 자식 클래스를 생성

# 많이 사용하는 프로그래밍 언어의 상속 문법 예제

1 ) JAVA

class Animal {
    void eat() {
        System.out.println("먹는다");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("짖는다");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();
        myDog.bark();
    }
}

2 ) python

class Animal:
    def eat(self):
        print("먹는다")

class Dog(Animal):
    def bark(self):
        print("짖는다")

myDog = Dog()
myDog.eat()
myDog.bark()

3 ) javascript

class Animal {
    eat() {
        console.log("먹는다");
    }
}

class Dog extends Animal {
    bark() {
        console.log("짖는다");
    }
}

let myDog = new Dog();
myDog.eat();
myDog.bark();

 

# 계층 구조

# 상속 과정

 

# is  a 관계

• is a subclass of B B
• is a superclass of A

# 상속 받는 것

부모의 protected 와 public 이 그대로 넘어온다.

 

# 상속

#include <iostream>
using std::cout;
using std::endl;
class A // 기본 클래스
{
int x;
public:
    void setX(int i){x=i;}
    void showX(){cout<<x<<endl;}
};
class B :public A //파생 클래스
{//아무 것도 없어요. 그러나!
};
int main() {
    A aa;
    aa.setX(1);
    aa.showX(); B bb;
    bb.setX(10);
    bb.showX();
    return 0;
}

부모의 public 을 상속 받았기에 bb.sentx 와 bb.show 를 접근할 수 있음

 

#  prirvate 상속

• private 쪽으로 상속이 변경
• 외부에서 접근이 안 되는 public 은 자식 클래스 멤버 함수에서부터만 접근이 가능
• 외부에서는 알지 못 함 비밀리에 상속이 됨

# 실습

#include <iostream>
using std::cout;
using std::endl;
class A
{
    int x; //int x=10; //가능?
    public :
    void setX(int i){x=i;}
    void showX(){cout<<x<<endl;}
};
class B:private A //비공개적으로 상속
{
int y;
public:
    void setY(int i){y=i;}
    void showY(){ cout<<y<<endl;}
};
int main()
{
    A aa;
    B bb;
    aa.setX(1);
    aa.showX();
    // bb.setX(1); // 오류, 자식의 private 쪽으로 상속이 되기에 자식 클래스에서만 사용이 가능
    bb.setY(2); // 파생클래스의 멤버접근
    
    // bb.showX(); // 오류
    bb.showY(); // 파생클래스의 멤버접근
    return 0;
}

 

main 함수에서 기본 클래스 A 의 public 멤버에 접근을 할 수 없다.

오류가 나는 이유는 자식 클래스에서만 상속이 되기에 자식 클래스 쪽에서만 사용이 가능하기 때문이다.

 

# 실습 2

#include <iostream>
using std::cout;
using std::endl;
class A
{
    int x;
public :
    void setX(int i){x=i;}
    void showX(){cout<<x<<endl;}
};
class B:private A //비공개적으로 상속받는다
{
    int y;
public:
    void setXY(int i, int j){setX(i) ;y=j;}
    // 기본 클래스의 public 멤버 접근
    void showXY(){showX() ;cout<<y<<endl;}
};
int main()
{
    B bb;
    bb.setXY(1,2); // 파생클래스의 멤버접근
    bb.showXY(); // 파생클래스의 멤버접근
    return 0;
}

private 으로 상속하게 되면 외부에서는 사용할 수 없고 자식 클래스 내부에서만 사용이 가능하다.

 

# protected 상속

부모의 속성이 자식에게 전부 protected 로 전달됨

protected 가 없을 시 private 로 상속

 

# protected 멤버와 public 상속

 

# 상속에서 소멸자와 생성자

#include <iostream>
using std::cout;
class A
{
public :
    A(){cout<<"A의 생성자\n";}
    ~A(){cout<<"A의 소멸자\n";}
};
class B:public A
{
public:
    B(){cout<<"B의 생성자\n";}
    ~B(){cout<<"B의 소멸자\n";}
};
int main()
{
    B ob;
    return 0;
}
//실제 B 클래스의 구성
class B:public A
{
public:
    A(){cout<<"A의 생성자 ";}
    ~A(){cout<<"A의 소멸자 ";}
    B(){cout<<"B의 생성자 ";}
    ~B(){cout<<"B의 소멸자 ";}
};

생성자는 부모 먼저 자식 호출 ( 자동 호출 )

소멸자는 자식 먼저 부모 호출

 

# 파생 클래스 생성자에서 기본 클래스 생성자에 매개 변수 전달 형식

#include <iostream>
using std::cout;
using std::endl;
class A{
    int a;
    public :
    A(int i){
    cout<<"A의 생성자\n";
    a=i;
}
    ~A(){cout<<"A의 소멸자\n";}
    void showA(){cout<<a<<'\n';}
};
class B:public A{
    int b;
public:
    B(int i, int j):A(i) {// i는 기본클래스 생성자의 매개변수로 전달
    cout<<"B의 생성자\n";
    b=j;
    }
    ~B(){cout<<"B의 소멸자\n";}
    void showB(){cout<<b<<endl;}
    
};
int main()
{
    B bb(10,20);
    bb.showA();
    bb.showB();
    return 0;
}

 

# 계층적 다중 상속에서 계층적 매개 변수 전달 

#include <iostream>
using std::cout;
using std::endl;
class B{ //할아버지
double d;
public :
B(double dd){d=dd;}
double getD() {return d;}
};
class D1:public B{ //아버지
int i;
public:
D1(double dd, int ii) :B(dd) {i=ii;}
int getI() {return i;}
};
class D2:public D1{ //자식
char c;
public:
D2(double dd, int ii, char cc) :D1(dd,ii) {c=cc;}
void print(){ cout<< "Double : "<<getD()<<endl;
// B 멤버 호출
cout<< "Int : "<<getI()<<endl;
// D1 멤버 호출
cout<< "Char : "<<c<<endl;
}
};
int main()
{
D2 d2(10.5,10,'H');
cout<<d2.getD()<<','<<d2.getI()<<endl;
// B, D1 멤버 호출
d2.print();
return 0;
}

계층적으로 상속을 받을 때 자식 쪽에서 부모의 생성자에게 값을 넘겨 주어야 함