Blog

#include <cstdio>
#include <memory>
#include <vector>

class Shape {                                   // 추상 클래스: 순수 가상 함수가 하나 이상
public:
    explicit Shape(const char* n) : name_(n) {} // 데이터 멤버와 생성자를 가질 수 있다
    virtual ~Shape() = default;
    virtual double area() const = 0;            // 순수 가상 함수
    void print() const { std::printf("%-7s %.2f\n", name_, area()); }   // 공통 구현
private:
    const char* name_;
};

class Circle : public Shape {
    double r_;
public:
    explicit Circle(double r) : Shape("circle"), r_(r) {}
    double area() const override { return 3.14159 * r_ * r_; }
};
class Rect : public Shape {
    double w_, h_;
public:
    Rect(double w, double h) : Shape("rect"), w_(w), h_(h) {}
    double area() const override { return w_ * h_; }
};

int main()
{
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(1));
    shapes.push_back(std::make_unique<Rect>(2, 3));
    for (const auto& s : shapes) s->print();
}

struct Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
};
struct Circle : Shape {
    double area() const override { return 3.14; }   // perimeter 미구현 -> Circle도 추상
};

int main()
{
    Shape s;
    Circle c;
}

#include <cstdio>

class Logger {
public:
    virtual ~Logger() = default;
    virtual void write(const char* msg) = 0;            // 반드시 재정의해야 하지만
};
void Logger::write(const char* msg)                     // 기본 구현도 제공할 수 있다
{
    std::printf("[default] %s\n", msg);
}

class FileLogger : public Logger {
public:
    void write(const char* msg) override
    {
        std::printf("[file] ");
        Logger::write(msg);                             // 명시적으로 기본 구현 호출
    }
};

int main()
{
    FileLogger f;
    Logger& l = f;
    l.write("started");
}

class Task {
public:
    Task() { run(); }                 // 직접 호출
    virtual ~Task() = default;
    virtual void run() = 0;
};
class Job : public Task { public: void run() override {} };
int main() { Job j; }

#include <cstdio>

class Task {
public:
    Task() { start(); }                              // 생성자에서 간접적으로 순수 가상 함수 호출
    virtual ~Task() = default;
    void start() { std::fputs("starting...\n", stderr); run(); }
    virtual void run() = 0;
};

class Job : public Task {
public:
    void run() override { std::fputs("Job::run\n", stderr); }
};

int main()
{
    Job j;
}

#include <cstdio>
#include <type_traits>

// 템플릿 메서드: 처리 순서는 추상 클래스가 고정하고, 단계별 구현은 파생 클래스가 채운다
class Exporter {
public:
    virtual ~Exporter() = default;
    void run()                                  // 비가상 공개 함수
    {
        open();
        for (int i = 1; i <= 2; ++i) write_row(i);
        close();
    }
protected:
    virtual void open() {}                      // 선택적 재정의 (기본 구현)
    virtual void write_row(int i) = 0;          // 필수 재정의
    virtual void close() {}
};

class CsvExporter : public Exporter {
    void open() override         { std::puts("id,value"); }
    void write_row(int i) override { std::printf("%d,%d\n", i, i * 10); }
};

class JsonExporter : public Exporter {
    void open() override         { std::puts("["); }
    void write_row(int i) override { std::printf("  {\"id\": %d}\n", i); }
    void close() override        { std::puts("]"); }
};

int main()
{
    CsvExporter{}.run();
    JsonExporter{}.run();
    std::printf("is_abstract<Exporter>=%d is_abstract<CsvExporter>=%d\n",
                std::is_abstract_v<Exporter>, std::is_abstract_v<CsvExporter>);
}