[C++]_10_상속

#include <iostream> // 입출력을 위한 헤더 파일
using std::cout;    // std::cout을 간단히 사용하기 위해 using 선언

// 클래스 A 정의: 부모 클래스
class A 
{
private: 
    // private 멤버 함수: 외부에서 직접 접근 불가
    void a1() { cout << "a1\n"; } // a1() 함수는 "a1"을 출력
    void a2() { cout << "a2\n"; } // a2() 함수는 "a2"을 출력

public: 
    // public 멤버 함수: 외부에서 접근 가능
    void b1() { cout << "b1\n"; } // b1() 함수는 "b1"을 출력
    void b2() { cout << "b2\n"; } // b2() 함수는 "b2"을 출력
    void b3() { cout << "b3\n"; } // b3() 함수는 "b3"을 출력
    void b4() { cout << "b4\n"; } // b4() 함수는 "b4"을 출력
};

// 클래스 B 정의: A 클래스를 상속받은 파생 클래스 (자식 클래스)
class B : public A 
{
    // 아무 멤버도 추가하지 않았지만, A의 public 및 protected 멤버는 상속됨
    // (private 멤버는 상속되지만 직접 접근할 수 없음)
};

int main() 
{
    A aa; // 클래스 A의 객체 생성
    // aa.b1(); 
    // 위 코드는 주석 처리되어 있어 실행되지 않음
    // 주석을 해제하면 b1() 함수 호출로 "b1" 출력 가능

    B bb; // 클래스 B의 객체 생성
    // bb는 A의 public 멤버(b1, b2, b3, b4)를 상속받아 사용할 수 있음
    // 하지만 main()에서 호출하는 부분이 없으므로 출력 없음

    return 0; // 프로그램 종료
}
```

### 코드 설명

1. **클래스 A**:
   - **private 멤버 함수**:
     - `a1()`과 `a2()`는 `private`로 선언되어 `main()` 함수나 외부 클래스에서 접근할 수 없습니다.
   - **public 멤버 함수**:
     - `b1()`, `b2()`, `b3()`, `b4()`는 `public`으로 선언되어 외부에서 호출 가능합니다.

2. **클래스 B**:
   - 클래스 `B`는 `public A`로 선언되어 클래스 `A`의 **public** 멤버와 **protected** 멤버를 상속받습니다.
   - 하지만 `private` 멤버(`a1()` 및 `a2()`)는 직접 사용할 수 없습니다. 상속은 되지만 접근이 제한됩니다.

3. **main 함수**:
   - 객체 `aa`는 클래스 `A`의 인스턴스입니다. 주석 처리된 `aa.b1();`을 활성화하면 `b1()` 함수가 호출되어 "b1"이 출력됩니다.
   - 객체 `bb`는 클래스 `B`의 인스턴스입니다. 클래스 `A`의 모든 public 멤버를 사용할 수 있으나, main 함수에서는 호출하지 않아 아무 출력도 없습니다.

### 이 코드에서 알 수 있는 점

- **상속**:
  - 클래스 `B`는 클래스 `A`를 상속받아 부모 클래스의 기능을 물려받습니다.
  - 상속받은 `public` 멤버는 자식 클래스에서 그대로 사용할 수 있습니다.
  - `private` 멤버는 상속되지만 외부에서 접근 불가능합니다.

- **접근 제어자**:
  - `private`: 클래스 내부에서만 접근 가능.
  - `public`: 어디서든 접근 가능.

- **주석 처리된 코드**:
  - `aa.b1();` 주석을 제거하면 객체 `aa`가 `b1()`을 호출하여 "b1"이 출력됩니다.

### 실행 결과 (주석 해제 시):
```plaintext
b1
```

아래는 다양한 프로그래밍 언어에서 상속의 기본적인 예제를 작성한 것입니다. 각 언어의 문법과 특징에 맞게 간단한 상속 구조를 보여줍니다.

---

### 1. **C++**
```cpp
#include <iostream>
using namespace std;

// 부모 클래스
class Animal {
public:
    void eat() {
        cout << "Eating...\n";
    }
};

// 자식 클래스
class Dog : public Animal {
public:
    void bark() {
        cout << "Barking...\n";
    }
};

int main() {
    Dog dog;
    dog.eat();  // 부모 클래스의 메서드 호출
    dog.bark(); // 자식 클래스의 메서드 호출
    return 0;
}
```

---

### 2. **Java**
```java
// 부모 클래스
class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

// 자식 클래스
class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 부모 클래스의 메서드 호출
        dog.bark(); // 자식 클래스의 메서드 호출
    }
}
```

---

### 3. **Python**
```python
# 부모 클래스
class Animal:
    def eat(self):
        print("Eating...")

# 자식 클래스
class Dog(Animal):
    def bark(self):
        print("Barking...")

# 실행
dog = Dog()
dog.eat()  # 부모 클래스의 메서드 호출
dog.bark() # 자식 클래스의 메서드 호출
```

---

### 4. **C#**
```csharp
using System;

class Animal
{
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Barking...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog();
        dog.Eat();  // 부모 클래스의 메서드 호출
        dog.Bark(); // 자식 클래스의 메서드 호출
    }
}
```

---

### 5. **JavaScript (ES6 Classes)**
```javascript
// 부모 클래스
class Animal {
    eat() {
        console.log("Eating...");
    }
}

// 자식 클래스
class Dog extends Animal {
    bark() {
        console.log("Barking...");
    }
}

// 실행
const dog = new Dog();
dog.eat();  // 부모 클래스의 메서드 호출
dog.bark(); // 자식 클래스의 메서드 호출
```

---

### 6. **Ruby**
```ruby
# 부모 클래스
class Animal
  def eat
    puts "Eating..."
  end
end

# 자식 클래스
class Dog < Animal
  def bark
    puts "Barking..."
  end
end

# 실행
dog = Dog.new
dog.eat  # 부모 클래스의 메서드 호출
dog.bark # 자식 클래스의 메서드 호출
```

---

### 7. **Kotlin**
```kotlin
// 부모 클래스
open class Animal {
    open fun eat() {
        println("Eating...")
    }
}

// 자식 클래스
class Dog : Animal() {
    fun bark() {
        println("Barking...")
    }
}

// 실행
fun main() {
    val dog = Dog()
    dog.eat()  // 부모 클래스의 메서드 호출
    dog.bark() // 자식 클래스의 메서드 호출
}
```

---

### 8. **Swift**
```swift
// 부모 클래스
class Animal {
    func eat() {
        print("Eating...")
    }
}

// 자식 클래스
class Dog: Animal {
    func bark() {
        print("Barking...")
    }
}

// 실행
let dog = Dog()
dog.eat()  // 부모 클래스의 메서드 호출
dog.bark() // 자식 클래스의 메서드 호출
```

---

### 공통 동작:
1. 부모 클래스는 **공통 동작**(`eat`)을 정의합니다.
2. 자식 클래스는 부모의 동작을 상속받아 **추가 동작**(`bark`)을 정의합니다.
3. 결과적으로 자식 객체는 부모와 자식 클래스의 메서드 모두를 사용할 수 있습니다.

시험문제 나옴

자식클래스 Dog

public을 사용해도 private는 절대 상속이 안된다.

시험에 자주 나옴

시험에 나옴

시험에 꼭 나옴

#include <iostream>
using std::cout;
using std::string;
using std::endl;


class Man {
protected:
    int age;       
    string name;   
public:
    
    Man(int age, string name) {
        this->age = age;
        this->name = name;
    }

    
    void m_show() {
        cout << "이름: " << name << endl;
        cout << "나이: " << age << endl;
    }
};


class Student : public Man {
protected:
    string ban;    
    string hak;     
public:
   
    Student(int age, string name, string ban, string hak) : Man(age, name) {
        this->ban = ban;
        this->hak = hak;
    }

   
    void s_show() {
        m_show(); 
        cout << "반: " << ban << endl;
        cout << "학번: " << hak << endl;
    }
};


class Teacher : public Man {
protected:
    string subject;  
    string course;    
public:
    
    Teacher(int age, string name, string subject, string course) : Man(age, name) {
        this->subject = subject;
        this->course = course;
    }

    
    void t_show() {
        m_show(); 
        cout << "과목: " << subject << endl;
        cout << "강의명: " << course << endl;
    }
};

int main()
{
    
    Student kks(20, "김컴소", "C반", "202012000");
    kks.s_show(); 
    Teacher hsh(40, "한미소", "전산", "C++프로그래밍");
    hsh.t_show(); // 

    return 0;
}