25.2. 프로그램언어 C++에서의 상속 및 다형성 이해

by

프로그램언어 C++의 상속 기본 개념

프로그램언어 C++의 상속은 객체지향 프로그래밍에서 중요한 개념 중 하나입니다. 상속은 기존 클래스의 특성을 다른 클래스가 이어받아 확장하거나 재사용할 수 있게 해줍니다. 이를 통해 코드의 재사용성과 유지보수성을 높일 수 있습니다.

상속을 사용하면 기존 클래스(부모 클래스 또는 기본 클래스)의 멤버 변수와 멤버 함수를 새로운 클래스(자식 클래스 또는 파생 클래스)에서 그대로 사용할 수 있습니다. 자식 클래스는 부모 클래스의 모든 특성을 물려받게 되며, 필요에 따라 새로운 멤버 변수나 멤버 함수를 추가할 수 있습니다.

아래는 C++에서 상속을 사용한 간단한 예제 코드입니다. Animal(동물) 클래스를 부모 클래스로 하고, Dog(개) 클래스를 자식 클래스로 만들어보겠습니다.


#include <iostream>

// 부모 클래스
class Animal {
public:
    void eat() {
        std::cout << "동물이 먹는다." << std::endl;
    }
};

// 자식 클래스
class Dog : public Animal {
public:
    void bark() {
        std::cout << "멍멍!" << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat(); // Animal 클래스의 멤버 함수 호출
    myDog.bark(); // Dog 클래스의 멤버 함수 호출

    return 0;
}

위의 코드에서 Animal 클래스는 eat()이라는 멤버 함수를 가지고 있습니다. Dog 클래스는 Animal 클래스를 상속받았으며, bark()라는 새로운 멤버 함수를 추가했습니다. main 함수에서는 Dog 클래스의 객체를 생성하고 eat()과 bark() 함수를 호출하여 부모 클래스와 자식 클래스의 멤버 함수를 모두 사용할 수 있음을 확인할 수 있습니다.

프로그램언어 C++의 다형성 기본 개념

다형성은 객체 지향 프로그래밍의 중요한 개념 중 하나로, C++에서도 지원됩니다. 다형성은 한 가지 인터페이스나 기능을 여러 방식으로 구현할 수 있는 능력을 의미합니다. 이는 코드의 재사용성과 유연성을 높여주며, 객체 지향 프로그래밍의 강력한 특징 중 하나입니다.

C++에서 다형성은 주로 가상 함수(virtual function)와 포인터를 통해 구현됩니다. 부모 클래스의 포인터를 사용하여 여러 종류의 자식 클래스 객체를 가리킬 수 있고, 이를 통해 다양한 동작을 수행할 수 있습니다. 다형성을 이용하면 코드의 유연성이 증가하고, 확장성이 향상됩니다.

예를 들어, 동물을 나타내는 부모 클래스인 'Animal'이 있고, 이를 상속받아 각각 'Dog'와 'Cat' 클래스가 있다고 가정해봅시다. 각 클래스는 'makeSound'라는 가상 함수를 가지고 있습니다. 이때, 부모 클래스의 포인터를 사용하여 다형성을 구현할 수 있습니다. 


#include <iostream>

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes a sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Cat meows" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Output: Dog barks
    animal2->makeSound(); // Output: Cat meows

    delete animal1;
    delete animal2;

    return 0;
}

위 예제 코드에서 'Animal' 클래스를 부모 클래스로 하고, 'Dog'와 'Cat' 클래스가 이를 상속받아 makeSound 함수를 오버라이딩하고 있습니다. main 함수에서는 'Animal' 포인터를 사용하여 'Dog'와 'Cat' 객체를 가리키고 있습니다. 이를 통해 다형성을 구현하고, 각 객체의 makeSound 함수가 호출됨에 따라 각자의 소리를 출력합니다.

프로그램언어 C++에서의 상속 및 다형성의 구현 방법

프로그램언어 C++에서의 상속 및 다형성은 객체지향 프로그래밍의 중요한 개념 중 하나입니다. 상속은 기존 클래스의 속성과 기능을 새로운 클래스에서 재사용할 수 있도록 해주는 기능이며, 다형성은 같은 이름의 메서드가 서로 다른 동작을 할 수 있도록 하는 기능입니다.

상속을 구현하기 위해서는 기존 클래스를 부모 클래스로 정의하고, 새로운 클래스를 자식 클래스로 정의합니다. 자식 클래스는 부모 클래스의 모든 멤버 변수와 메서드를 상속받아 사용할 수 있습니다. 다음은 상속의 구현 예제 코드입니다.


#include <iostream>

// 부모 클래스
class Parent {
public:
    void display() {
        std::cout << "Parent class" << std::endl;
    }
};

// 자식 클래스
class Child : public Parent {
public:
    void show() {
        std::cout << "Child class" << std::endl;
    }
};

int main() {
    Child childObj;
    childObj.display(); // Parent class
    childObj.show();    // Child class

    return 0;
}

다형성은 상속과 함께 사용되어 같은 이름의 메서드가 서로 다른 동작을 할 수 있도록 합니다. 다형성은 가상 함수(virtual function)를 통해 구현됩니다. 가상 함수는 부모 클래스에서 정의되고 자식 클래스에서 재정의할 수 있는 함수입니다. 다음은 다형성의 구현 예제 코드입니다.


#include <iostream>

// 부모 클래스
class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing shape" << std::endl;
    }
};

// 자식 클래스 1
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing circle" << std::endl;
    }
};

// 자식 클래스 2
class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing square" << std::endl;
    }
};

int main() {
    Circle circleObj;
    Square squareObj;

    Shape* shapePtr;

    shapePtr = &circleObj;
    shapePtr->draw(); // Drawing circle

    shapePtr = &squareObj;
    shapePtr->draw(); // Drawing square

    return 0;
}

프로그램언어 C++에서의 상속 및 다형성 예제

상속과 다형성은 객체지향 프로그래밍에서 중요한 개념입니다. C++에서도 이러한 개념을 지원하며, 이를 통해 코드의 재사용성과 유지보수성을 높일 수 있습니다.

먼저, 상속은 기존 클래스의 특성을 그대로 물려받아 새로운 클래스를 정의하는 것을 말합니다. 이를 통해 코드 중복을 줄이고 구조를 계층적으로 나타낼 수 있습니다. 예를 들어, 동물 클래스를 상속받아 고양이 클래스와 강아지 클래스를 만들 수 있습니다.

다음으로, 다형성은 같은 이름의 메서드가 서로 다른 동작을 할 수 있도록 하는 기능을 말합니다. 이는 상속과 함께 사용되어, 부모 클래스의 포인터나 참조를 통해 여러 종류의 자식 클래스 객체를 다룰 수 있습니다.

아래는 C++에서 상속과 다형성을 이해하는 간단한 예제코드입니다.


#include <iostream>

// 부모 클래스
class Animal {
public:
    virtual void makeSound() {
        std::cout << "동물 소리" << std::endl;
    }
};

// 자식 클래스 1
class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "야옹" << std::endl;
    }
};

// 자식 클래스 2
class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "멍멍" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Cat();
    Animal* animal2 = new Dog();

    animal1->makeSound(); // "야옹" 출력
    animal2->makeSound(); // "멍멍" 출력

    delete animal1;
    delete animal2;

    return 0;
}

프로그램언어 C++에서의 상속 및 다형성의 활용

상속과 다형성은 C++ 프로그래밍에서 중요한 개념입니다. 상속은 기존 클래스의 특성을 새로운 클래스가 물려받는 것을 의미하며, 다형성은 같은 이름의 메서드가 서로 다른 기능을 수행할 수 있는 특성을 말합니다.

이 두 가지 개념을 함께 사용하면 코드의 재사용성을 높일 뿐만 아니라 유연하고 확장 가능한 프로그램을 작성할 수 있습니다. 예를 들어, 상속을 통해 기존 클래스의 멤버 변수와 메서드를 새로운 클래스에서 재활용할 수 있고, 다형성을 이용하여 여러 객체를 동일한 인터페이스로 다룰 수 있습니다.

아래는 C++에서 상속과 다형성을 활용한 간단한 예제 코드입니다. 


#include <iostream>

// 기본 동물 클래스
class Animal {
public:
    virtual void makeSound() {
        std::cout << "동물 소리" << std::endl;
    }
};

// 강아지 클래스, Animal 클래스를 상속받음
class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "멍멍" << std::endl;
    }
};

// 고양이 클래스, Animal 클래스를 상속받음
class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "야옹" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // "멍멍" 출력
    animal2->makeSound(); // "야옹" 출력

    delete animal1;
    delete animal2;

    return 0;
}

Leave a Comment