알고리즘 : 명예의 전당
문제링크 항상 그렇듯 문제를 이해하는게 제일 힘들었다 이후는 결국 고정된 길이의 공간에 최저값을 갱신하며 최저값을 넣어주면 되는 문제기 때문에 어떤 컨테이너를 쓸지 고민을 했었는데 다른 풀이를 보면 multiset이나 queue를 사용한 것을 볼 수 있다. 이진트리 구조를 가진 객체의 경우 삭제시 비효율 적으로 알고 있다 vector를 이용하려다가 list를 썼다 sort후 최저값만 받으면 그만 이니까. list가 제일 좋은 선택이지 않을까 생각한다
강의 : 디자인 패턴
디자인 패턴이란 "개발 시, 반복적으로 등장하는 문제를 해결하기 위한 일반화 된 솔루션" 정의할 수 있다. 경험이 많은 선배님들의 피땀어린 결정체라 볼 수 있으며 다음과 같이 구성되어 있다.
Creational Patterns
Singletone Patterns
객체를 하나만 유지해야할 경우 사용하는 패턴이다. 사실상 전역변수
#include <iostream>
using namespace std;
class Airplane
{
private:
static Airplane* instance; // 유일한 비행기 객체를 가리킬 정적 포인터
int positionX; // 비행기의 X 위치
int positionY; // 비행기의 Y 위치
// private 생성자: 외부에서 객체 생성 금지
Airplane() : positionX(0), positionY(0) {
cout << "Airplane Created at (" << positionX << ", " << positionY << ")" << endl;
}
public:
// 복사 생성자와 대입 연산자를 삭제하여 복사 방지
Airplane(const Airplane&) = delete;
Airplane& operator=(const Airplane&) = delete;
// 정적 메서드: 유일한 비행기 인스턴스를 반환
static Airplane* getInstance() {
if (instance == nullptr) {
instance = new Airplane();
}
return instance;
}
// 비행기 위치 이동
void move(int deltaX, int deltaY) {
positionX += deltaX;
positionY += deltaY;
cout << "Airplane moved to (" << positionX << ", " << positionY << ")" << endl;
}
// 현재 위치 출력
void getPosition() const {
cout << "Airplane Position: (" << positionX << ", " << positionY << ")" << endl;
}
};
// 정적 멤버 초기화
Airplane* Airplane::instance = nullptr;
// 메인 함수 (사용 예시)
int main() {
// 유일한 비행기 인스턴스를 가져옴
Airplane* airplane = Airplane::getInstance();
airplane->move(10, 20); // 비행기 이동
airplane->getPosition();
// 또 다른 요청도 같은 인스턴스를 반환
Airplane* sameAirplane = Airplane::getInstance();
sameAirplane->move(-5, 10); // 비행기 이동
sameAirplane->getPosition();
return 0;
}Abstract Factory Pattern
추상 팩토리 패턴은 연관성이 있는 객체 군이 여러개 있을 경우 이들을 묶어 추상화 하고, 어떤 구체적인 상황이 주어지면 팩토리 객체에서 집합으로 묶은 객체 군을 구현화 하는 생성 패턴이다. 클라이언트에서 특정 객체를 사용할 때 팩토리 클래스만을 참조하여 특정 객체에 대한 구현부를 감추어 역할과 구현을 분리시킬 수 있다.
즉, 추상 팩토리의 핵심은 제품'군'집합을 타입별로 찍어낼 수 있다는 점이 포인트이며 예를들어 모니터, 마우스, 키보드를 묶은 전자 제품군이 있는데 이들을 또 삼성 제품군이냐, 애플 제품군이냐 로지텍 제품군이냐에 따라 집합이 브랜드 명으로 여러갈래로 나뉘게 될 떄, 복잡하게 묶이는 이러한 제품군들을 관리와 확장하기 용이하게 패턴화 한 것이 추상 팩토리이다.
둘 다 팩토리 객체를 통해 구체적인 타입을 감추고, 객체 생성에 관여하는 패턴 임에는 동일하다. 또한 공장 클래스가 제품 클래스를 각각 나뉘어 느슨한 결합 구조를 구성하는 모습 역시 둘이 유사하다.그러나 주의할 것은 추상 팩토리 패턴이 메서드 패턴의 상위 호환이 아니라는 점이다. 두 패턴의 차이는 명확하기 때문에 상황에 따라 적절한 선택을 해야 한다.
예를 들어 팩토리 메서드 패턴은 객체 생성 이후 해야 할 일의 공통점 정의하는데 초점을 맞추는 반면, 추상 팩토리 패턴은 생성 할 객체 집합 군의 공통점에 초점을 맞춘다.
단, 둘의 유사점과 차이점을 조합해 복합 패턴을 구성하는 것 또한 가능하다.
장점
- 객체를 생성하는 코드를 분리하여 클라이언트 코드와 결합도를 낮춘다.
- 제품 군을 쉽게 대체 할 수 있다.
- 단일 책임 원칙 준수.
- 개방 / 폐쇄 원칙 준수
단점
- 각 구현체 마다 팩토리 객체들을 구현해야 하기 때문에 객체가 늘면 클래스가 증가한다(복잡성 증가)
- 추상팩토리의 세부 사항이 변경되면 모든 팩토리에 수정이 필요
- 새로운 객체를 지원하는 것이 어렵다. 새로운 객체가 추가되면 팩토리 구현 로직 자체를 변경해야함
class AbstractFactory
{
public:
virtual class ConcreteProduct* createProduct() = NULL;
};
class ConcreteFactory :
public AbstractFactory
{
public:
virtual class ConcreteProduct* createProduct() override
{
return new ConcreteProduct();
}
};
class AbstractProduct
{
};
class ConcreteProduct :
public AbstractProduct
{
};
int main()
{
ConcreteFactory factory;
factory.createProduct();
return NULL;
}위에 코드처럼 생성되는 객체와 생성하는 객체를 분리한 것이다.
Stuctual Patterns
Decorator patterns
객체의 결합을 통해 기능을 동적으로 유연하게 확장 할 수 있게 해주는 패턴이다. 즉, 기본 기능에 추가할 수 있는 기능의 종류가 많은 경우에 각 추가 기능을 Decorator 클래스로 정의 한 후 필요한 Decorator객체를 조합함으로써 추가 기능의 조합을 설계하는 방식이다.
#include <iostream>
#include <string>
using namespace std;
// **추상 컴포넌트 (Component): Pizza**
// - 피자 객체의 기본 구조를 정의하는 인터페이스입니다.
// - 모든 피자는 이름(`getName`)과 가격(`getPrice`)을 가져야 합니다.
class Pizza {
public:
virtual ~Pizza() {}
virtual string getName() const = 0; // 피자의 이름 반환
virtual double getPrice() const = 0; // 피자의 가격 반환
};
// **구체 컴포넌트 (Concrete Component): BasicPizza**
// - 기본 피자 클래스입니다.
// - 피자의 기본 베이스(이름과 가격)를 구현합니다.
class BasicPizza : public Pizza {
public:
string getName() const {
return "Basic Pizza"; // 기본 피자의 이름
}
double getPrice() const {
return 5.0; // 기본 피자의 가격
}
};
// **데코레이터 추상 클래스 (Decorator): PizzaDecorator**
// - 기존 피자의 기능을 확장하기 위한 데코레이터의 기본 구조를 정의합니다.
// - 내부적으로 `Pizza` 객체를 감싸며, 이름과 가격에 추가적인 기능을 제공합니다.
class PizzaDecorator : public Pizza {
protected:
Pizza* pizza; // 기존의 피자 객체를 참조합니다.
public:
// 데코레이터는 피자 객체를 받아서 감쌉니다.
PizzaDecorator(Pizza* p) : pizza(p) {}
// 소멸자에서 내부 피자 객체를 삭제합니다.
virtual ~PizzaDecorator() {
delete pizza;
}
};
// **구체 데코레이터 (Concrete Decorators): Cheese, Pepperoni, Olive**
// - 각각의 토핑 데코레이터는 `PizzaDecorator`를 상속받아 이름과 가격을 확장합니다.
// 치즈 토핑 데코레이터
class CheeseDecorator : public PizzaDecorator {
public:
CheeseDecorator(Pizza* p) : PizzaDecorator(p) {}
string getName() const {
// 기존 피자의 이름에 " + Cheese"를 추가
return pizza->getName() + " + Cheese";
}
double getPrice() const {
// 기존 피자의 가격에 치즈 추가 비용 1.5를 더함
return pizza->getPrice() + 1.5;
}
};
// 페퍼로니 토핑 데코레이터
class PepperoniDecorator : public PizzaDecorator {
public:
PepperoniDecorator(Pizza* p) : PizzaDecorator(p) {}
string getName() const {
// 기존 피자의 이름에 " + Pepperoni"를 추가
return pizza->getName() + " + Pepperoni";
}
double getPrice() const {
// 기존 피자의 가격에 페퍼로니 추가 비용 2.0을 더함
return pizza->getPrice() + 2.0;
}
};
// 올리브 토핑 데코레이터
class OliveDecorator : public PizzaDecorator {
public:
OliveDecorator(Pizza* p) : PizzaDecorator(p) {}
string getName() const {
// 기존 피자의 이름에 " + Olive"를 추가
return pizza->getName() + " + Olive";
}
double getPrice() const {
// 기존 피자의 가격에 올리브 추가 비용 0.7을 더함
return pizza->getPrice() + 0.7;
}
};
// **클라이언트 코드**
// - 피자와 데코레이터를 조합하여 최종 피자를 생성하고, 정보를 출력합니다.
int main() {
// 1. 기본 피자를 생성합니다.
Pizza* pizza = new BasicPizza();
// 2. 치즈 토핑을 추가합니다.
pizza = new CheeseDecorator(pizza);
// 3. 페퍼로니 토핑을 추가합니다.
pizza = new PepperoniDecorator(pizza);
// 4. 올리브 토핑을 추가합니다.
pizza = new OliveDecorator(pizza);
// 5. 최종 피자 정보 출력
cout << "Pizza: " << pizza->getName() << endl; // 피자의 이름 출력
cout << "Price: $" << pizza->getPrice() << endl; // 피자의 가격 출력
// 6. 메모리 해제
delete pizza;
return 0;
}
위의 소스와 같이 추상화된 컴포넌트 객체가 있고, 인스턴스된 컴포넌트 객체가 하위 Decorator를 소유하는 개념을 가진다.
Behavioral Patterns
Observer Pattern
옵저버패턴은 관찰가 관찰하고 있는 대상의 상태가 변화할 때마다 관찰자들에게 통지하고 알림을 받아 조치를 취하는 행동 패턴이다.
#include <iostream>
#include <vector>
#include <string>
using namespace std;
// Observer 인터페이스
// - Observer 패턴에서 상태 변화를 알림받는 객체들의 공통 인터페이스
// - Observer들은 이 인터페이스를 구현하여 `update` 메서드를 통해 데이터를 전달받음
class Observer {
public:
virtual ~Observer() = default; // 가상 소멸자
virtual void update(int data) = 0; // 데이터 업데이트 메서드 (순수 가상 함수)
};
// Subject 클래스 (엑셀 시트 역할)
// - 데이터의 상태 변화를 관리하며, 모든 등록된 Observer들에게 변경 사항을 알림
class ExcelSheet {
private:
vector<Observer*> observers; // Observer들을 저장하는 리스트
int data; // 현재 데이터 상태
public:
ExcelSheet() : data(0) {} // 생성자: 초기 데이터 값은 0
// Observer 등록 메서드
// - 새로운 Observer를 등록하여 변경 사항 알림을 받을 수 있도록 추가
void attach(Observer* observer) {
observers.push_back(observer);
}
// 데이터 변경 알림 메서드
// - 등록된 모든 Observer들의 `update` 메서드를 호출하여 데이터 변경 사항을 알림
void notify() {
for (Observer* observer : observers) {
observer->update(data); // 각 Observer에게 데이터를 전달
}
}
// 데이터 설정 메서드
// - 데이터를 변경하고 변경 사항을 모든 Observer에게 알림
void setData(int newData) {
data = newData; // 새로운 데이터로 갱신
cout << "ExcelSheet: Data updated to " << data << endl;
notify(); // Observer들에게 알림
}
};
// 구체적인 Observer 클래스: BarChart (막대 차트)
// - 데이터를 막대 그래프로 표현
class BarChart : public Observer {
public:
void update(int data) { // 데이터 업데이트 시 호출됨
cout << "BarChart: Displaying data as vertical bars: ";
for (int i = 0; i < data; ++i) {
cout << "|"; // 데이터 값만큼 막대 출력
}
cout << " (" << data << ")" << endl;
}
};
// 구체적인 Observer 클래스: LineChart (라인 차트)
// - 데이터를 선형 그래프로 표현
class LineChart : public Observer {
public:
void update(int data) { // 데이터 업데이트 시 호출됨
cout << "LineChart: Plotting data as a line: ";
for (int i = 0; i < data; ++i) {
cout << "-"; // 데이터 값만큼 선 출력
}
cout << " (" << data << ")" << endl;
}
};
// 구체적인 Observer 클래스: PieChart (파이 차트)
// - 데이터를 파이 그래프로 표현
class PieChart : public Observer {
public:
void update(int data) { // 데이터 업데이트 시 호출됨
cout << "PieChart: Displaying data as a pie chart slice: ";
cout << "Pie [" << data << "%]" << endl; // 데이터 값 출력 (가정: % 비율로 표현)
}
};
// 메인 함수
int main() {
// Subject 생성
ExcelSheet excelSheet; // 데이터를 관리하는 엑셀 시트 객체 생성
// Observer 객체 생성 (각 차트 객체)
BarChart* barChart = new BarChart(); // 막대 차트 생성
LineChart* lineChart = new LineChart(); // 라인 차트 생성
PieChart* pieChart = new PieChart(); // 파이 차트 생성
// Observer 등록
// - 각 차트(Observer)를 엑셀 시트(Subject)에 등록
excelSheet.attach(barChart);
excelSheet.attach(lineChart);
excelSheet.attach(pieChart);
// 데이터 변경 테스트
// - 데이터를 변경하면 등록된 모든 Observer들이 알림을 받고 화면에 갱신
excelSheet.setData(5); // 데이터 변경: 5
excelSheet.setData(10); // 데이터 변경: 10
// 메모리 해제
// - 동적 할당된 Observer(차트) 객체 삭제
delete barChart;
delete lineChart;
delete pieChart;
return 0;
}
느낀점
생각보다 디자인 패턴 이라는 것들이 특정상황에 적용되는 것들이 아니라 유동적으로 다양하게 적용된다는 것을 모르고 사용했을 때 잘 느꼈던거 같다. 남이 잘 짜놓은거 보고 그냥 이렇게 사용할 수 있구나 싶었던 것들이 이런 패턴들이 숨어 있었구나 알게 되었고 특성을 알고 적용하는 연습이 필요할 거 같다.
취미로 게임하는사람