휘뚜루 마뚜루-TJ

Wireshark(와이어샤크)로 TLS로 암호화된 패킷 복호화 하기

developer-tj — Thu, 25 Apr 2024 19:36:38 +0900

네트워크 트래픽을 모니터링하고 분석하는데 널리 사용되는 Wireshark는 TLS(Transport Layer Security)와 같은 암호화 프로토콜을 사용하여 보호된 패킷을 캡처할 수 있습니다.

하지만 TLS로 암호화된 패킷을 캡처했다고 해서 패킷의 내용을 쉽게 이해할 수는 없습니다.

이러한 암호화된 패킷을 복호화하여 내용을 확인하려면 Wireshark에서 몇 가지 추가 설정이 필요합니다.

다음은 TLS로 암호화된 패킷을 복호화하는 방법을 알아봅니다.

TLS로 암호화된 패킷을 복호화 하기

1. C:\SSLKEYLOGFILE 폴더를 생성합니다.

2. 찾기에서 "시스템 환경 변수 편집" 으로 들어갑니다.

3. "환경 변수" -> 시스템 변수 "새로 만들기" 를 클릭합니다.

4. 새 시스템 변수에 변수 이름을 SSLKEYLOGFILE 로 입력하고, 변수 값을 C:\SSLKEYLOGFILE\sslkey.log 로 입력 후 확인 합니다.

5. 크롬으로 www.google.com 에 접속합니다.

6. C:\SSLKEYLOGFILE 폴더에 sslkey.log 파일이 생성된 것을 확인합니다.

7. Wireshark를 실행하고 "편집" -> "설정" 으로 들어갑니다.

8. "protocols" -> "TLS" 를 선택합니다.

9. (Pre)-Master-Secret log filename 에 C:\SSLKEYLOGFILE\sslkey.log 경로를 입력 후 확인합니다.

10. 패킷 캡처 시작을 하고 네이버에서 test 란 문구로 검색을 합니다.

11. 복호화 된 패킷를 확인합니다.

12. 설정에서 ."protocols" -> "TLS" -> (Pre)-Master-Secret log filename 항목을 삭제하고 다시 해당 패킷을 확인합니다.

13. 다시 암호화 된 패킷을 확인 합니다.

Wireshark(와이어샤크) 설치 방법

developer-tj — Sun, 21 Apr 2024 14:21:36 +0900

WireShark란 무엇인가요?

WireShark는 네트워크 패킷 분석 도구로, 네트워크 트래픽을 캡처하고 분석하는 데 사용됩니다. 이 도구는 개발자, 시스템 관리자, 보안 전문가 및 네트워크 엔지니어들 사이에서 널리 사용되며, 다양한 용도로 활용됩니다.

WireShark의 중요성

네트워크 문제 해결: 네트워크에서 발생하는 문제를 신속하게 진단하고 해결하는 데 도움이 됩니다. 패킷 레벨에서 트래픽을 분석하여 문제의 근본 원인을 찾을 수 있습니다.
보안 분석: 악의적인 트래픽을 감지하고 네트워크 보안 위협을 식별하는 데 사용됩니다. WireShark를 사용하여 네트워크에서 이상한 활동을 모니터링하고 보안 이벤트를 탐지할 수 있습니다.
프로토콜 분석: 다양한 네트워크 프로토콜을 지원하며, 프로토콜의 동작을 이해하고 문제를 해결하는 데 도움이 됩니다.
네트워크 성능 튜닝: 네트워크 성능을 개선하기 위해 트래픽 패턴을 분석하고 최적화할 수 있습니다.

WireShark의 기능

다양한 네트워크 프로토콜 지원: Ethernet, TCP/IP, UDP, HTTP, SSL 등 다양한 프로토콜을 지원합니다.
실시간 패킷 캡처: 네트워크 트래픽을 실시간으로 캡처하여 분석할 수 있습니다.
패킷 필터링: 원하는 프로토콜이나 주소로 패킷을 필터링하여 원하는 정보만 볼 수 있습니다.
패킷 분석 및 통계: 패킷을 분석하고 통계를 생성하여 네트워크 동작을 이해하고 문제를 해결할 수 있습니다.

WireShark 설치 방법

1. https://www.wireshark.org 에 접속합니다.

2. "Get started" 를 클릭합니다.

3. "Windows x64 Installer" 선택하여 다운로드 받습니다. (자신의 OS에 맞는 버전을 선택합니다.)

4. 다운받은 Wireshark-4.2.4-x64.exe 파일을 실행합니다.

Next 클릭

( Npcap를 설치하기 위한 확인 내용입니다.

Npcap은 네트워크 패킷 캡처 및 인젝션 라이브러리입니다.

이는 윈도우 운영 체제에서 네트워크 트래픽을 캡처하고 분석하기

위한 도구와 애플리케이션에서 사용됩니다.

Npcap은 WireShark와 같은 네트워크 분석 도구에서

패킷 캡처 기능을 제공하기 위해 설치됩니다.)

Install 클릭

( USBPcap 를 설치하기 위한 확인 내용입니다.

USBPcap은 USB 데이터를 캡처하고 분석하기 위한 도구입니다.

네트워크 분석 시에는 사용하지 않아 기본으로 설치하지 않습니다.)

설치 도중 Npcap 설치 화면이 별도로 뜹니다.

I Agree 클릭

Install 클릭

Next 클릭

Finish 클릭

( Npcap 설치가 끝나고 Wireshark 설치가 이어서 진행됩니다.)

Next 클릭

Finish 클릭

5. 설치된 Wireshark를 실행합니다. (설치 경로 "C:\Program Files\Wireshark\Wireshark.exe" )

6. 실행된 Wireshark를 확인합니다.

냄새 14. 성의 없는 요소(Lazy Element)

developer-tj — Sat, 8 Apr 2023 12:00:44 +0900

성의 없는 요소(Lazy Element)는 프로그램에서 사용하지 않는 코드 또는 기능을 가리키는 코드 냄새 중 하나입니다.
이러한 코드는 작성 시 개발자가 과거 또는 현재의 개발자가 아닌 미래의 다른 개발자들을 위해 만드는 것이 좋습니다.

성의없는 요소는 코드의 복잡도를 증가시키고, 유지보수와 확장성을 어렵게 만듭니다.
또한 이러한 코드는 프로그램의 실행 속도를 늦출 수 있습니다.

성의없는 요소를 제거하는 방법 중 하나는, 불필요한 코드를 제거하고 단순하게 유지보수할 수 있는 코드로 수정하는 것입니다.
이러한 작업은 코드 리팩터링 과정에서 수행됩니다.
예를 들어, 사용하지 않는 변수나 함수를 제거하거나, 중복된 코드를 제거하거나, 불필요한 주석을 제거하는 등의 작업이 이에 해당합니다.

또 다른 방법으로는, 불필요한 기능을 가진 코드를 주석 처리하거나, 디버깅을 위해 남겨두는 것입니다.
이 경우에도, 코드를 정리하고 주석을 추가하여 코드의 가독성을 높일 필요가 있습니다.

성의없는 요소를 제거하면 코드의 가독성과 유지보수성을 향상시키고, 불필요한 코드 실행으로 인한 성능 저하를 방지할 수 있습니다.

적용 가능한 리팩터링 기법

리팩터링 기법. 반복문을 파이프라인으로 바꾸기(Replace Loop with Pipeline)

developer-tj — Fri, 7 Apr 2023 12:00:29 +0900

반복문을 파이프라인으로 바꾸기(Replace Loop with Pipeline)는 컬렉션을 다루는 로직에서 특히 효과적인 기법입니다.
기존에는 반복문을 사용하여 컬렉션의 원소를 하나씩 처리했지만, 이를 파이프라인으로 변경하여 더욱 간결하고 가독성이 좋은 코드로 만드는 것입니다.

파이프라인은 입력 데이터를 처리하고 출력 데이터를 생성하는 여러 단계로 나누어져 있는 프로세스를 의미합니다.
각 단계는 이전 단계의 출력을 입력으로 받아 다음 단계의 출력을 생성합니다.
이러한 구조를 활용하여 컬렉션을 처리하는 코드를 구현할 수 있습니다.

예를 들어, 다음과 같은 반복문 코드가 있다고 가정해 봅시다.


std::vector numbers = {1, 2, 3, 4, 5};
std::vector doubledNumbers;
for (int number : numbers) {
    doubledNumbers.push_back(number * 2);
}

위 코드는 벡터 numbers의 모든 원소를 순회하며 각 원소에 2를 곱한 결과를 doubledNumbers 벡터에 추가하는 코드입니다.
하지만 이를 파이프라인으로 변경하면 다음과 같이 더 간결하고 가독성이 좋은 코드를 구현할 수 있습니다.


std::vector numbers = {1, 2, 3, 4, 5};
std::transform(numbers.begin(), numbers.end(), std::back_inserter(doubledNumbers), [](int number) { return number * 2; });

위 코드에서는 std::transform() 함수를 사용하여 벡터 numbers의 모든 원소에 2를 곱한 결과를 doubledNumbers 벡터에 추가하고 있습니다.
std::transform() 함수는 STL의 알고리즘 중 하나로, 입력 범위와 출력 범위를 지정하고 변환 함수를 지정하여 입력 범위의 모든 요소를 변환한 결과를 출력 범위에 저장합니다.
이렇게 변환된 데이터를 다시 다른 함수에 입력으로 넘겨 파이프라인을 구성할 수 있습니다.
이 코드는 반복문을 사용한 기존 코드보다 더 간결하고 가독성이 좋습니다.

반복문을 파이프라인으로 변경하는 것은 코드의 가독성과 유지보수성을 향상시키는 데 큰 도움이 됩니다.
특히 컬렉션을 다루는 코드에서는 파이프라인을 활용하여 불필요한 반복문을 제거하고 간결하고 명확한 코드를 구현하는 것이 좋습니다.

std::variant

developer-tj — Thu, 6 Apr 2023 12:00:49 +0900

std::variant는 C++17에서 추가된 표준 라이브러리 클래스로, 여러 타입 중 하나를 저장할 수 있는 유연한 클래스입니다.
이전에는 유사한 기능을 하는 std::any를 사용해왔으나, std::variant는 더욱 타입 안전하고 간결하게 사용할 수 있습니다.
std::variant는 일반적으로 union과 비슷한 방식으로 작동합니다. 즉, 저장된 값은 선택한 타입의 크기와 정렬 요구 사항을 따릅니다.

std::variant는 다음과 같은 특징을 갖습니다.
- 여러 타입 중 하나를 저장할 수 있는 유연한 클래스
- 저장된 값은 선택한 타입의 크기와 정렬 요구 사항을 따름
- 선언할 때 모든 가능한 타입을 정의해야 하며, 선언 후에는 해당 타입들 중 하나의 값만 저장할 수 있음
- switch문과 함께 사용할 수 있는 visit 함수를 제공하여, 저장된 값의 타입에 따라 다른 작업을 수행할 수 있음
- 참조, 배열 또는 void 타입은 보유할 수 없음
- 동일한 타입을 한 번 이상 보유하고, 동일한 타입의 다르게 cv-qualified 된 버전을 보유할 수 있음

std::variant는 다음과 같이 선언할 수 있습니다.

std::variant<int, double, std::string> v;

위 코드는 int, double, std::string 중 하나를 저장할 수 있는 std::variant를 선언하는 것입니다.
선언 후에는 v에 int, double, std::string 중 하나의 값을 저장할 수 있습니다.

std::variant의 값을 가져오기 위해서는 std::get 함수를 사용할 수 있습니다.

std::variant<int, double, std::string> v;
v = 42;
int i = std::get<int>(v); // v에 저장된 int 값을 가져옴

위 코드는 v에 int 값 42를 저장하고, std::get<int>(v)를 사용하여 v에 저장된 int 값을 가져오는 것입니다.

std::variant를 switch문과 함께 사용하려면, visit 함수를 사용할 수 있습니다.
visit 함수는 각 타입에 대해 작업을 수행하는 함수 객체를 인수로 받습니다.

std::variant<int, double, std::string> v;
v = 3.14;

std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "v contains an int: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "v contains a double: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "v contains a string: " << arg << '\n';
    }
}, v);

위 코드는 v에 double 값 3.14를 저장하고, visit 함수를 사용하여 v에 저장된 값의 타입에 따라 다른 작업을 수행하는 것입니다.

다음은 서로 다른 타입의 메시지를 큐에 입력받는 샘플 코드입니다.

#include <queue>
#include <variant>
#include <string>
#include <iostream>

struct MessageA {
    int type;
    double data;
};

struct MessageB {
    int type;
    char data[20];
};

struct MessageC {
    int type;
    std::string data;
};

using Message = std::variant<MessageA, MessageB, MessageC>;

int main() {
    std::queue<Message> messageQueue;
    
    messageQueue.push(MessageA{1, 3.14});
    messageQueue.push(MessageB{2, "hello world"});
    messageQueue.push(MessageC{3, "foo bar"});
    
    while (!messageQueue.empty()) {
        const auto& message = messageQueue.front();
        
        std::visit([](const auto& msg) {
            using MsgType = std::decay_t<decltype(msg)>;
            if constexpr (std::is_same_v<MsgType, MessageA>) {
                std::cout << "MessageA received with data: " << msg.data << std::endl;
            } else if constexpr (std::is_same_v<MsgType, MessageB>) {
                std::cout << "MessageB received with data: " << msg.data << std::endl;
            } else if constexpr (std::is_same_v<MsgType, MessageC>) {
                std::cout << "MessageC received with data: " << msg.data << std::endl;
            }
        }, message);
        
        messageQueue.pop();
    }
    
    return 0;
}

냄새 13. 반복문(Loops)

developer-tj — Wed, 5 Apr 2023 12:00:14 +0900

반복문(Loops)을 사용하는 것이 코드 작성의 효율성을 높일 수 있지만, 반복문이 중첩되거나 복잡한 조건문과 함께 사용되는 경우 코드의 복잡성이 증가하고 코드를 이해하기 어려워질 수 있습니다.

반복문의 문제점 중 하나는 다른 로직과 함께 사용되는 경우 유지보수성이 낮아질 수 있다는 것입니다.

예를 들어, 아래의 코드에서 반복문은 사이즈를 계산하고, 각 색상의 평균값을 계산하는 두 가지 다른 로직과 함께 사용됩니다.


int size = 0;
double redSum = 0.0;
double greenSum = 0.0;
double blueSum = 0.0;
for (int i = 0; i < pixels.size(); ++i) {
    size++;
    redSum += pixels[i].red();
    greenSum += pixels[i].green();
    blueSum += pixels[i].blue();
}
double redAverage = redSum / size;
double greenAverage = greenSum / size;
double blueAverage = blueSum / size;

위 코드를 아래와 같이 수정한다면 반복문을 포함하지 않고도 코드의 가독성과 유지보수성을 높일 수 있습니다.


int size = pixels.size();
double redSum = std::accumulate(pixels.begin(), pixels.end(), 0.0,
    [](double sum, const Pixel& p) { return sum + p.red(); });
double greenSum = std::accumulate(pixels.begin(), pixels.end(), 0.0,
    [](double sum, const Pixel& p) { return sum + p.green(); });
double blueSum = std::accumulate(pixels.begin(), pixels.end(), 0.0,
    [](double sum, const Pixel& p) { return sum + p.blue(); });
double redAverage = redSum / size;
double greenAverage = greenSum / size;
double blueAverage = blueSum / size;

위 코드에서는 std::accumulate()를 사용하여 반복문 없이 요소의 합을 계산할 수 있습니다.
이렇게 하면 코드의 가독성이 높아지고, 필요한 로직을 분리할 수 있으며, 재사용성도 높아집니다.
이와 같은 방식으로 반복문을 대체하여 코드를 개선할 수 있습니다.

적용 가능한 리팩터링 기법

반복문을 파이프라인으로 바꾸기(Replace Loop with Pipeline)

냄새 12. 반복되는 switch문(Repeated Switches)

developer-tj — Tue, 4 Apr 2023 12:00:58 +0900

반복되는 switch문(Repeated Switches)은 여러 개의 switch 문이 동일한 조건식을 검사하는 경우를 말합니다.

예를 들어, 다음과 같은 코드를 생각해보겠습니다.


void processAnimalSound(Animal* animal) {
    switch (animal->getType()) {
        case AnimalType::CAT:
            // process cat sound
            break;
        case AnimalType::DOG:
            // process dog sound
            break;
        case AnimalType::COW:
            // process cow sound
            break;
        default:
            // process default sound
            break;
    }
}

void processAnimalMovement(Animal* animal) {
    switch (animal->getType()) {
        case AnimalType::CAT:
            // process cat movement
            break;
        case AnimalType::DOG:
            // process dog movement
            break;
        case AnimalType::COW:
            // process cow movement
            break;
        default:
            // process default movement
            break;
    }
}

위 코드에서 processAnimalSound()와 processAnimalMovement() 함수에서 각각 switch문이 존재하며, 동일한 조건식을 사용하고 있습니다.
이 경우 조건식이 변경되거나 다른 동물이 추가될 때 마다 모든 switch문을 변경해주어야 하는 번거로움이 있습니다.

이러한 문제를 해결하기 위해 각각의 동물을 클래스로 정의하고, 해당 클래스에서 메서드를 정의하여 동물의 소리와 움직임을 처리하도록 수정할 수 있습니다.
이렇게 되면 switch문을 제거하고, 동물 클래스의 새로운 클래스를 추가하면 됩니다.


class Animal {
public:
    virtual void makeSound() = 0;
    virtual void move() = 0;
};

class Cat : public Animal {
public:
    void makeSound() override {
        // process cat sound
    }
    void move() override {
        // process cat movement
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        // process dog sound
    }
    void move() override {
        // process dog movement
    }
};

class Cow : public Animal {
public:
    void makeSound() override {
        // process cow sound
    }
    void move() override {
        // process cow movement
    }
};

void processAnimal(Animal* animal) {
    animal->makeSound();
    animal->move();
}

이렇게 하면, 새로운 동물이 추가될 때마다 새로운 동물 클래스를 만들어 주면 되기 때문에 코드의 유지보수성이 높아집니다. 또한, 코드 중복도 줄일 수 있으며, 가독성도 좋아집니다.

적용 가능한 리팩터링 기법

조건부 로직을 다형성으로 바꾸기(Replace Conditional with Polymorphism)

리팩터링 기법. 조건부 로직을 다형성으로 바꾸기(Replace Conditional with Polymorphism)

developer-tj — Mon, 3 Apr 2023 12:00:23 +0900

조건부 로직을 다형성으로 바꾸기(Replace Conditional with Polymorphism)란 객체의 타입에 따라 분기되는 조건부 로직을 상속 구조를 이용하여 다형성을 적용하여 코드를 간결하고 유연하게 만드는 리팩터링 방법입니다.

조건부 로직은 보통 if-else문, switch-case문 등으로 구현되며, 객체의 타입에 따라 다른 로직을 수행하도록 설계되어 있습니다.
이러한 코드는 코드의 유지보수성이 나쁘며, 새로운 객체 타입이 추가될 때마다 코드의 수정이 필요합니다.
따라서 이러한 조건부 로직을 다형성을 이용하여 분리하고, 객체의 타입에 따라 해당하는 메서드를 호출하는 방식으로 코드를 변경하는 것이 좋습니다.

이 방법을 사용하면, 객체의 타입에 따라 다른 동작을 수행해야 할 때 새로운 객체 타입을 추가하기가 쉬워집니다.
또한, 각 객체 타입마다 특정 동작을 수행하는 메서드가 존재하므로, 코드의 가독성이 높아지고 유지보수성도 향상됩니다.

조건부 로직을 다형성으로 바꾸는 방법은 다음과 같습니다.

조건문에 해당하는 부분을 클래스의 메소드로 추출합니다.
추출한 메소드를 추상 메소드로 정의하고, 상속받을 클래스에서 구현합니다.
추상 클래스를 정의하고, 추상 메소드를 포함합니다.
추상 클래스를 상속받아 각 상황에 맞는 클래스를 구현합니다.

간단한 예시로, 도형 클래스를 다루는 코드를 예로 들어보겠습니다.
이전 코드에서는 각 도형의 타입에 따라 분기를 수행하였습니다.


class Shape {
public:
    enum Type {
        Circle,
        Rectangle,
        Triangle
    };

    Type getType() const { return type_; }

    double getArea() const {
        switch (type_) {
            case Circle:
                return PI * radius_ * radius_;
            case Rectangle:
                return width_ * height_;
            case Triangle:
                return 0.5 * base_ * height_;
        }
    }

private:
    Type type_;
    double radius_;
    double width_;
    double height_;
    double base_;
};

이를 조건부 로직에서 다형성을 이용하여 변경하면, 각 도형 클래스를 만들고 각 클래스마다 getArea() 메서드를 구현하게 됩니다.


class Shape {
public:
    virtual double getArea() const = 0;
};

class Circle : public Shape {
public:
    Circle(double radius) : radius_(radius) {}
    double getArea() const override { return PI * radius_ * radius_; }
private:
    double radius_;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double getArea() const override { return width_ * height_; }
private:
    double width_;
    double height_;
};

class Triangle : public Shape {
public:
    Triangle(double base, double height) : base_(base), height_(height) {}
    double getArea() const override { return 0.5 * base_ * height; }
private:
    double base;
    double height_;
};

위 코드는 다형성을 이용하여 조건부 로직을 처리하도록 바꾼 예시 코드입니다.

기존 코드에서는 다양한 도형에 대한 정보를 하나의 클래스 내에 저장하고 있었습니다.
하지만 이를 다형성을 이용하여 각 도형마다 별도의 클래스로 분리하고, 공통적으로 필요한 부분은 부모 클래스인 Shape 클래스에 정의하여 사용하는 것입니다.

위 코드에서 Circle, Rectangle, Triangle 클래스는 각 도형에 대한 클래스입니다.
이들은 모두 Shape 클래스를 상속받아 getArea() 함수를 오버라이딩하고 있습니다.
이렇게 하면 다른 클래스에서는 Shape 포인터를 이용하여 각 도형의 넓이를 구할 수 있습니다.
이는 조건문 없이 다형성을 이용하여 간결하고 유연한 코드를 작성할 수 있도록 도와줍니다.

리팩터링 기법. 타입 코드를 서브클래스로 바꾸기(Replace Type Code with Subclasses)

developer-tj — Sun, 2 Apr 2023 12:00:05 +0900

타입 코드(Type Code)란, 하나의 클래스 안에서 여러 종류의 객체를 표현하기 위해 사용하는 코드를 말합니다.
이는 예를 들어, 도형 클래스 안에서 도형의 종류를 표시하기 위한 숫자나 문자열과 같은 것을 말할 수 있습니다.

타입 코드를 서브클래스로 바꾸기(Replace Type Code with Subclasses)는 이러한 타입 코드를 사용하는 것을 서브클래스로 분리하는 방법입니다.
타입 코드에 따라 객체의 특성이 달라지는 것을 서브클래스로 만들어 표현함으로써, 객체지향적인 설계를 더욱 강화할 수 있습니다.

서브클래스로 분리하는 방법은, 기존 클래스의 타입 코드에 해당하는 각 서브클래스를 만든 다음, 기존 클래스에서 해당 타입 코드를 제거하고 대신 적절한 서브클래스의 인스턴스를 생성하여 반환하도록 수정하는 것입니다.
이렇게 하면 기존 클래스의 복잡도를 낮추고, 타입 코드에 따라 달라지는 동작을 서브클래스 내부에서 캡슐화함으로써 코드 유지보수성을 높일 수 있습니다.

예를 들어, 도형 클래스에서 타입 코드로 "사각형", "원", "삼각형" 등을 사용하고 있다면, 이를 각각의 서브클래스로 만들어 분리할 수 있습니다.
이렇게 하면 각 도형의 특성이 달라지는 경우에도 새로운 서브클래스를 추가하거나 수정하는 것만으로도 쉽게 처리할 수 있습니다.

다음은 도형 클래스에서 타입 코드로 "사각형", "원", "삼각형"을 사용하는 예제 코드가 있습니다.


enum class ShapeType {
  kRectangle,
  kCircle,
  kTriangle
};

class Shape {
public:
  Shape(ShapeType type, double width, double height, double radius, double base, double altitude)
    : type_(type), width_(width), height_(height), radius_(radius), base_(base), altitude_(altitude) {}

  double area() const {
    switch (type_) {
      case ShapeType::kRectangle:
        return width_ * height_;
      case ShapeType::kCircle:
        return PI * radius_ * radius_;
      case ShapeType::kTriangle:
        return 0.5 * base_ * altitude_;
      default:
        return 0.0;
    }
  }

  double perimeter() const {
    switch (type_) {
      case ShapeType::kRectangle:
        return 2 * (width_ + height_);
      case ShapeType::kCircle:
        return 2 * PI * radius_;
      case ShapeType::kTriangle:
        return base_ + 2 * sqrt(base_ * base_ + 0.25 * altitude_ * altitude_);
      default:
        return 0.0;
    }
  }

private:
  ShapeType type_;
  double width_;
  double height_;
  double radius_;
  double base_;
  double altitude_;
};

타입 코드를 서브클래스로 바꾸기를 적용합니다.


class Shape {
public:
  virtual double area() const = 0;
  virtual double perimeter() const = 0;
};

class Rectangle : public Shape {
public:
  Rectangle(double width, double height) : width_(width), height_(height) {}

  double area() const override { return width_ * height_; }
  double perimeter() const override { return 2 * (width_ + height_); }

private:
  double width_;
  double height_;
};

class Circle : public Shape {
public:
  Circle(double radius) : radius_(radius) {}

  double area() const override { return PI * radius_ * radius_; }
  double perimeter() const override { return 2 * PI * radius_; }

private:
  double radius_;
};

class Triangle : public Shape {
public:
  Triangle(double base, double altitude) : base_(base), altitude_(altitude) {}

  double area() const override { return 0.5 * base_ * altitude_; }
  double perimeter() const override { return base_ + 2 * sqrt(base_ * base_ + 0.25 * altitude_ * altitude_); }

private:
  double base_;
  double altitude_;
};

위의 코드에서 Shape 클래스를 추상 클래스로 만들고 area()와 perimeter() 함수를 순수 가상 함수로 선언합니다.
그리고 Rectangle, Circle, Triangle 클래스를 Shape 클래스를 상속받아 만듭니다.
이렇게 하면 Shape 클래스를 사용하는 곳에서는 객체의 실제 타입을 알 필요 없이 다형성을 이용해 area()와 perimeter() 함수를 호출할 수 있습니다.
이렇게 하면 새로운 도형을 추가하더라도 Shape 클래스를 수정하지 않고 새로운 서브 클래스를 만들어서 추가할 수 있습니다.

리팩터링 기법. 기본형을 객체로 바꾸기(Replace Primitive with Object)

developer-tj — Sat, 1 Apr 2023 12:00:22 +0900

기본형을 객체로 바꾸기(Replace Primitive with Object)는 기본형 변수를 사용하는 대신 새로운 클래스를 정의하고 그 클래스의 인스턴스를 사용하는 방식으로 코드를 개선하는 리팩터링 기법입니다.

기본형 변수는 더 큰 데이터 구조와 연결되어 있지 않기 때문에 코드의 가독성과 유지보수성을 저해할 수 있습니다.
반면, 객체는 속성과 행동을 갖는 더 복잡한 데이터 구조를 나타낼 수 있습니다.

예를 들어, 기본형 변수로 통화를 나타내는 경우, 환율이나 기타 통화와 관련된 정보를 캡슐화하고, 통화 간의 변환을 수행할 수 있는 새로운 클래스를 정의할 수 있습니다.

또 다른 예로, 기본형 변수로 날짜를 나타내는 경우, 시간대, 일괄처리 및 기타 관련 정보를 캡슐화하고, 날짜 간의 비교, 연산 및 계산을 수행할 수 있는 새로운 클래스를 정의할 수 있습니다.

이 기법은 코드의 가독성, 유지보수성, 확장성을 향상시킬 수 있습니다.
하지만, 객체로 바꾸는 것은 기본형 변수를 사용하는 것보다 조금 더 많은 코드를 작성해야 하기 때문에 일부 개발자들은 이 기법을 사용하지 않는 경우도 있습니다.

기본형을 객체로 바꾸는 예시로 학생의 시험 점수를 저장하는 시스템이 있다고 가정해봅시다.


class Student {
public:
    Student(std::string name, int math_score, int science_score, int english_score)
        : name_(name), math_score_(math_score), science_score_(science_score), english_score_(english_score) {}

    std::string GetName() const { return name_; }
    int GetMathScore() const { return math_score_; }
    int GetScienceScore() const { return science_score_; }
    int GetEnglishScore() const { return english_score_; }

private:
    std::string name_;
    int math_score_;
    int science_score_;
    int english_score_;
};

Student 클래스는 시험 점수를 int로 저장하고 있습니다.
시험 점수를 객체로 바꾸어 보겠습니다.

먼저, 학생의 시험 점수를 저장할 Score 클래스를 정의합니다.


class Score {
public:
    Score(int math, int science, int english) : math_(math), science_(science), english_(english) {
        if (math_ < 0 || math_ > 100) {
            throw std::invalid_argument("math score should be between 0 and 100.");
        }
        if (science_ < 0 || science_ > 100) {
            throw std::invalid_argument("science score should be between 0 and 100.");
        }
        if (english_ < 0 || english_ > 100) {
            throw std::invalid_argument("english score should be between 0 and 100.");
        }
    }

    void setMath(int math) {
        if (math < 0 || math > 100) {
            throw std::invalid_argument("math score should be between 0 and 100.");
        }
        math_ = math;
    }

    void setScience(int science) {
        if (science < 0 || science > 100) {
            throw std::invalid_argument("science score should be between 0 and 100.");
        }
        science_ = science;
    }

    void setEnglish(int english) {
        if (english < 0 || english > 100) {
            throw std::invalid_argument("english score should be between 0 and 100.");
        }
        english_ = english;
    }

    int math() const { return math_; }
    int science() const { return science_; }
    int english() const { return english_; }

    double average() const { return static_cast(math_ + science_ + english_) / 3; }

private:
    int math_;
    int science_;
    int english_;
};

각 학생의 정보를 저장할 Student 클래스를 정의합니다.
Student 클래스는 이름과 Score 객체를 멤버 변수로 가지고 있습니다.


class Student {
public:
    Student(const std::string& name, const Score& score) : name_(name), score_(score) {}

    const std::string& name() const { return name_; }
    const Score& score() const { return score_; }

private:
    std::string name_;
    Score score_;
};

이제, main 함수에서 학생 정보를 생성하고 출력해보겠습니다.


int main() {
    Score score1(90, 85, 95);
    Student student1("Alice", score1);

    Score score2(80, 75, 85);
    Student student2("Bob", score2);

    std::cout << student1.name() << "'s average score: " << student1.score().average() << std::endl;
    std::cout << student2.name() << "'s average score: " << student2.score().average() << std::endl;

    return 0;
}

기존에는 각 학생의 시험 점수를 int형으로 저장했지만, Score 클래스를 사용하여 각 과목의 점수를 멤버 변수로 저장하고 평균 점수를 계산할 수 있도록 했습니다.
이렇게 하면 데이터를 더욱 직관적으로 표현할 수 있으며, Score 클래스에서 추가적인 연산이 필요할 경우 Score 클래스 내부에 멤버 함수를 정의해주기만 하면 됩니다.