추상 클래스와 순수 가상 함수

virtual 반환타입 함수이름(매개변수) = 0;

#include <iostream>
#include <string>

class Shape {
public:
    // 일반 가상 함수 (선택적 구현)
    virtual void displayInfo() const {
        std::cout << "이것은 일반적인 도형입니다." << std::endl;
    }

    // 순수 가상 함수: 객체를 생성할 구체 클래스에는 비순수 최종 재정의 함수가 필요합니다.
    virtual double calculateArea() const = 0; // 도형의 넓이는 도형마다 다르므로 구현을 강제

    // 가상 소멸자 (Shape*로 파생 객체를 delete하는 계약)
    virtual ~Shape() {
        std::cout << "Shape 소멸자 호출.\n";
    }
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    void displayInfo() const override {
        std::cout << "이것은 원입니다." << std::endl;
    }

    double calculateArea() const override { // 순수 가상 함수 구현
        return 3.14159 * radius * radius;
    }
    ~Circle() override { std::cout << "Circle 소멸자 호출.\n"; }
};

class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    void displayInfo() const override {
        std::cout << "이것은 사각형입니다." << std::endl;
    }

    double calculateArea() const override { // 순수 가상 함수 구현
        return width * height;
    }
    ~Rectangle() override { std::cout << "Rectangle 소멸자 호출.\n"; }
};

int main() {
    // Shape s; // 컴파일 오류! 순수 가상 함수가 있는 추상 클래스는 객체를 직접 생성할 수 없습니다.

    Circle c(5.0);
    Rectangle r(4.0, 6.0);

    // 다형성 활용 (기반 클래스 포인터)
    Shape* s1 = &c;
    Shape* s2 = &r;

    s1->displayInfo();     // 출력: 이것은 원입니다.
    std::cout << "원의 넓이: " << s1->calculateArea() << std::endl; // 계산값은 약 78.54이며 출력 자릿수는 스트림 정밀도에 따름

    s2->displayInfo();     // 출력: 이것은 사각형입니다.
    std::cout << "사각형의 넓이: " << s2->calculateArea() << std::endl; // 출력: 사각형의 넓이: 24

    // 동적 할당된 객체
    Shape* s3 = new Circle(7.0);
    std::cout << "새로운 원의 넓이: " << s3->calculateArea() << std::endl;
    delete s3; // Circle 소멸자 -> Shape 소멸자 호출 (가상 소멸자 덕분)

    return 0;
}

#include <iostream>
#include <string>

// 인터페이스 역할을 하는 추상 클래스
class ILogger { // 'I' 접두사는 인터페이스임을 나타내는 관례
public:
    // 순수 가상 함수: 모든 로거는 메시지를 기록하는 기능을 반드시 가져야 함
    virtual void log(const std::string& message) = 0;

    // 순수 가상 함수: 모든 로거는 에러 메시지를 기록하는 기능을 가져야 함
    virtual void logError(const std::string& errorMessage) = 0;

    // 가상 소멸자: 파생 클래스의 소멸자 호출 보장
    virtual ~ILogger() {
        std::cout << "ILogger 소멸자 호출.\n";
    }
};

// 파일 로거의 인터페이스 예시: 여기서는 콘솔 출력으로 대체
class FileLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "[FILE_LOG]: " << message << std::endl;
        // 예시용 콘솔 출력; 실제 파일 쓰기는 구현하지 않음
    }

    void logError(const std::string& errorMessage) override {
        std::cerr << "[FILE_ERROR]: " << errorMessage << std::endl;
        // 예시용 표준 오류 출력; 실제 파일 쓰기는 구현하지 않음
    }
    ~FileLogger() override { std::cout << "FileLogger 소멸자 호출.\n"; }
};

// 콘솔에 로그를 기록하는 클래스
class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "[CONSOLE_LOG]: " << message << std::endl;
    }

    void logError(const std::string& errorMessage) override {
        std::cerr << "[CONSOLE_ERROR]: " << errorMessage << std::endl;
    }
    ~ConsoleLogger() override { std::cout << "ConsoleLogger 소멸자 호출.\n"; }
};

// 로그 기능을 사용하는 함수
void processData(ILogger* logger) {
    logger->log("데이터 처리 시작.");
    // ... 데이터 처리 로직 ...
    logger->logError("데이터 처리 중 오류 발생!");
    logger->log("데이터 처리 완료.");
}

int main() {
    FileLogger fileLog;
    ConsoleLogger consoleLog;

    std::cout << "--- 파일 로거 사용 ---\n";
    processData(&fileLog); // FileLogger 객체를 ILogger 포인터로 전달

    std::cout << "\n--- 콘솔 로거 사용 ---\n";
    processData(&consoleLog); // ConsoleLogger 객체를 ILogger 포인터로 전달

    // 동적 할당 예시
    ILogger* currentLogger = nullptr;
    if (true) { // 어떤 조건에 따라 로거 선택
        currentLogger = new FileLogger();
    } else {
        currentLogger = new ConsoleLogger();
    }
    std::cout << "\n--- 동적 할당 로거 사용 ---\n";
    currentLogger->log("동적 로거 메시지.");
    delete currentLogger; // FileLogger 소멸자 -> ILogger 소멸자

    return 0;
}