언어/C++

7일차)C++ 문법 단기간에 끝내기!! 기초 문법편<<CLASS

CodeMuscle 2024. 12. 5. 17:53
반응형

 

 

안녕하세요. CodeMuscle 입니다.

 

C++ 클래스와 객체 지향 프로그래밍 (OOP) 가이드

C++에서 **객체 지향 프로그래밍 (Object-Oriented Programming, OOP)**은 프로그램을 구성하는 기본 단위를 클래스와 객체로 만들어 더 직관적이고 유지보수하기 쉽게 코드를 작성할 수 있도록 도와줍니다. 이번 글에서는 OOP의 주요 개념인 클래스, 상속, 다형성, 추상화, 캡슐화에 대해 살펴보겠습니다.

1. 클래스와 객체

클래스는 데이터와 해당 데이터를 조작하는 함수를 묶어 놓은 사용자 정의 자료형입니다. 객체는 클래스로부터 생성된 인스턴스입니다. 객체는 클래스의 설계도를 바탕으로 실체화된 데이터입니다.

// 클래스와 객체 예시
class Car {
public:
    std::string color;
    void drive() {
        std::cout << "Driving the car." << std::endl;
    }
};

int main() {
    Car myCar; // 객체 생성
    myCar.color = "Red";
    myCar.drive(); // 메소드 호출
    return 0;
}
// 여러 객체 생성
class Dog {
public:
    std::string breed;
    void bark() {
        std::cout << "Woof!" << std::endl;
    }
};

int main() {
    Dog dog1, dog2;
    dog1.breed = "Bulldog";
    dog2.breed = "Beagle";
    
    dog1.bark();
    dog2.bark();
    return 0;
}
// 클래스 내부 함수 호출 예시
class Person {
public:
    std::string name;
    void introduce() {
        std::cout << "Hello, my name is " << name << "." << std::endl;
    }
};

int main() {
    Person person;
    person.name = "Alice";
    person.introduce();
    return 0;
}

2. 접근 제어자 (public, private, protected)

  • public: 외부에서 접근 가능한 멤버입니다.
  • private: 클래스 내부에서만 접근 가능한 멤버입니다.
  • protected: 클래스 내부와 상속받은 클래스에서 접근 가능한 멤버입니다.
// 접근 제어자 사용 예시
class Person {
private:
    std::string name;
public:
    void setName(std::string newName) {
        name = newName;
    }
    std::string getName() {
        return name;
    }
};

int main() {
    Person person;
    person.setName("Bob");
    std::cout << "Name: " << person.getName() << std::endl;
    return 0;
}
// private 멤버 변수 보호 예시
class Account {
private:
    double balance;
public:
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    double getBalance() {
        return balance;
    }
};

int main() {
    Account myAccount;
    myAccount.deposit(500);
    std::cout << "Balance: " << myAccount.getBalance() << std::endl;
    return 0;
}
// protected 멤버 예시
class Parent {
protected:
    int age;
};

class Child : public Parent {
public:
    void setAge(int a) {
        age = a;
    }
    int getAge() {
        return age;
    }
};

int main() {
    Child child;
    child.setAge(10);
    std::cout << "Age: " << child.getAge() << std::endl;
    return 0;
}

3. 생성자와 소멸자

생성자는 객체가 생성될 때 자동으로 호출되는 함수로, 객체의 초기화를 담당합니다. 소멸자는 객체가 소멸될 때 호출되어 자원을 해제하는 역할을 합니다.

// 생성자와 소멸자 예시
class Animal {
public:
    Animal() {
        std::cout << "Animal created." << std::endl;
    }
    ~Animal() {
        std::cout << "Animal destroyed." << std::endl;
    }
};

int main() {
    Animal a;
    return 0;
}
// 여러 생성자 사용 예시
class Car {
public:
    Car() {
        std::cout << "Car created with default constructor." << std::endl;
    }
    Car(std::string color) {
        std::cout << "Car created with color: " << color << std::endl;
    }
};

int main() {
    Car car1;
    Car car2("Blue");
    return 0;
}
// 소멸자 호출 확인 예시
class Resource {
public:
    Resource() {
        std::cout << "Resource acquired." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource released." << std::endl;
    }
};

int main() {
    Resource res;
    return 0;
}

4. 상속 (Inheritance)

상속은 기존 클래스를 기반으로 새로운 클래스를 정의하는 기능으로, 코드 재사용성을 높입니다.

// 단일 상속 예시
class Vehicle {
public:
    void start() {
        std::cout << "Vehicle starting." << std::endl;
    }
};

class Car : public Vehicle {
public:
    void honk() {
        std::cout << "Car honking." << std::endl;
    }
};

int main() {
    Car myCar;
    myCar.start();
    myCar.honk();
    return 0;
}
// 다중 상속 예시
class A {
public:
    void show() {
        std::cout << "A's show." << std::endl;
    }
};

class B {
public:
    void display() {
        std::cout << "B's display." << std::endl;
    }
};

class C : public A, public B {
};

int main() {
    C obj;
    obj.show();
    obj.display();
    return 0;
}
// 상속을 통한 코드 재사용성 예시
class Animal {
public:
    void eat() {
        std::cout << "Animal eating." << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << "Dog barking." << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat();
    myDog.bark();
    return 0;
}

5. 다형성 (Polymorphism)

다형성은 하나의 인터페이스로 여러 형태를 구현할 수 있게 하는 기능입니다. 함수 오버라이딩과 가상 함수를 통해 구현됩니다.

// 가상 함수 예시
class Animal {
public:
    virtual void sound() {
        std::cout << "Some generic animal sound." << std::endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        std::cout << "Bark!" << std::endl;
    }
};

int main() {
    Animal* a = new Dog();
    a->sound(); // 출력: Bark!
    delete a;
    return 0;
}
// 함수 오버라이딩 예시
class Base {
public:
    virtual void print() {
        std::cout << "Base print function." << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived print function." << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    b->print(); // 출력: Derived print function.
    delete b;
    return 0;
}
// 다형성을 이용한 함수 호출 예시
class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape." << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

void displayDrawing(Shape* shape) {
    shape->draw();
}

int main() {
    Circle circle;
    displayDrawing(&circle); // 출력: Drawing a circle.
    return 0;
}

6 

// 추상 클래스 예시
class Shape {
public:
    virtual void draw() = 0; // 순수 가상 함수
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle." << std::endl;
    }
};

int main() {
    Shape* s = new Circle();
    s->draw();
    delete s;
    return 0;
}
// 여러 추상 클래스 사용 예시
class Animal {
public:
    virtual void makeSound() = 0;
};

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

int main() {
    Animal* a = new Cat();
    a->makeSound();
    delete a;
    return 0;
}
// 인터페이스 구현 예시
class Drawable {
public:
    virtual void draw() = 0;
};

class Rectangle : public Drawable {
public:
    void draw() override {
        std::cout << "Drawing Rectangle." << std::endl;
    }
};

int main() {
    Drawable* d = new Rectangle();
    d->draw();
    delete d;
    return 0;
}

7. 캡슐화 (Encapsulation)

캡슐화는 데이터를 숨기고, 필요한 함수만 공개하여 데이터의 무결성을 보장합니다. 데이터 은닉을 통해 클래스의 외부에서 멤버 변수에 직접 접근하는 것을 막고, getter와 setter 함수를 사용합니다.

// 캡슐화 예시
class BankAccount {
private:
    double balance;
public:
    void setBalance(double amount) {
        if (amount >= 0) balance = amount;
    }
    double getBalance() {
        return balance;
    }
};

int main() {
    BankAccount account;
    account.setBalance(1000.0);
    std::cout << "Balance: " << account.getBalance() << std::endl;
    return 0;
}
// setter와 getter 사용 예시
class Student {
private:
    int age;
public:
    void setAge(int a) {
        if (a > 0) age = a;
    }
    int getAge() {
        return age;
    }
};

int main() {
    Student student;
    student.setAge(20);
    std::cout << "Age: " << student.getAge() << std::endl;
    return 0;
}
// 데이터 보호를 위한 캡슐화 예시
class Employee {
private:
    double salary;
public:
    void setSalary(double s) {
        if (s >= 0) salary = s;
    }
    double getSalary() {
        return salary;
    }
};

int main() {
    Employee emp;
    emp.setSalary(50000);
    std::cout << "Salary: " << emp.getSalary() << std::endl;
    return 0;
}

마무리

C++의 객체 지향 프로그래밍은 클래스와 객체를 통해 프로그램을 구조화하고, 상속, 다형성, 추상화, 캡슐화를 이용해 코드의 재사용성과 유지보수성을 높입니다. 이러한 개념들을 잘 이해하고 활용하면 더 나은 품질의 프로그램을 작성할 수 있습니다. 

 

 

 

 

 

 

반응형