Blog

#include <cstdio>
#include <string>
#include <vector>

// 인터페이스: 데이터 없이 순수 가상 함수와 가상 소멸자만
struct Readable {
    virtual ~Readable() = default;
    virtual std::string read() = 0;
};
struct Writable {
    virtual ~Writable() = default;
    virtual void write(const std::string& s) = 0;
};

// 하나의 클래스가 여러 인터페이스를 구현
class MemoryFile : public Readable, public Writable {
    std::vector<std::string> lines_;
    std::size_t pos_ = 0;
public:
    void write(const std::string& s) override { lines_.push_back(s); }
    std::string read() override { return pos_ < lines_.size() ? lines_[pos_++] : "<eof>"; }
};

void produce(Writable& w) { w.write("hello"); w.write("world"); }   // 필요한 능력만 요구
void consume(Readable& r) { for (int i = 0; i < 3; ++i) std::printf("%s\n", r.read().c_str()); }

int main()
{
    MemoryFile f;
    produce(f);
    consume(f);
    std::printf("sizeof(Readable)=%zu sizeof(MemoryFile)=%zu\n", sizeof(Readable), sizeof(MemoryFile));
}

#include <cstdio>
#include <string>
#include <vector>

struct Clock {                                   // 외부 의존성을 인터페이스로 추상화
    virtual ~Clock() = default;
    virtual long now_ms() const = 0;
};

struct Mailer {
    virtual ~Mailer() = default;
    virtual void send(const std::string& to, const std::string& body) = 0;
};

class SessionGuard {                             // 테스트 대상: 구체 타입을 모른다
    const Clock& clock_;
    Mailer& mailer_;
    long started_;
public:
    SessionGuard(const Clock& c, Mailer& m) : clock_(c), mailer_(m), started_(c.now_ms()) {}
    void check(const std::string& user)
    {
        if (clock_.now_ms() - started_ > 30'000) mailer_.send(user, "session expired");
    }
};

// 테스트용 가짜 구현
struct FakeClock : Clock {
    long t = 0;
    long now_ms() const override { return t; }
};
struct RecordingMailer : Mailer {
    std::vector<std::string> sent;
    void send(const std::string& to, const std::string& body) override { sent.push_back(to + ": " + body); }
};

int main()
{
    FakeClock clock;
    RecordingMailer mailer;
    SessionGuard g(clock, mailer);

    clock.t = 10'000; g.check("kim");
    std::printf("after 10s: %zu mails\n", mailer.sent.size());
    clock.t = 31'000; g.check("kim");
    std::printf("after 31s: %zu mails (%s)\n", mailer.sent.size(), mailer.sent.back().c_str());
}

#include <cstdio>
#include <stdexcept>

// NVI(Non-Virtual Interface): 공개 함수는 비가상, 구현 지점은 private 가상
class Storage {
public:
    virtual ~Storage() = default;
    void put(int key, int value)                 // 사전·사후 조건을 한 곳에서 강제
    {
        if (key < 0) throw std::invalid_argument("negative key");
        do_put(key, value);
        ++writes_;
    }
    int writes() const { return writes_; }
private:
    virtual void do_put(int key, int value) = 0; // 파생 클래스는 이것만 구현
    int writes_ = 0;
};

class MemStorage : public Storage {
    void do_put(int key, int value) override { std::printf("  mem[%d]=%d\n", key, value); }
};

int main()
{
    MemStorage m;
    Storage& s = m;
    s.put(1, 100);
    try { s.put(-1, 5); } catch (const std::exception& e) { std::printf("  rejected: %s\n", e.what()); }
    std::printf("  writes=%d\n", s.writes());
}

#include <concepts>
#include <cstdio>
#include <string>

// 컴파일 타임 인터페이스: 상속 없이 "이런 멤버가 있어야 한다"를 요구
template <typename T>
concept Serializer = requires(const T& s, int v) {
    { s.serialize(v) } -> std::convertible_to<std::string>;
    { T::format_name } -> std::convertible_to<const char*>;
};

struct JsonSer {
    static constexpr const char* format_name = "json";
    std::string serialize(int v) const { return "{\"v\":" + std::to_string(v) + "}"; }
};
struct CsvSer {
    static constexpr const char* format_name = "csv";
    std::string serialize(int v) const { return "v," + std::to_string(v); }
};

void dump(const Serializer auto& s, int v)
{
    std::printf("[%s] %s\n", s.format_name, s.serialize(v).c_str());
}

int main()
{
    dump(JsonSer{}, 7);
    dump(CsvSer{}, 7);
    std::printf("sizeof(JsonSer)=%zu (vptr 없음)\n", sizeof(JsonSer));
}

#include <concepts>
#include <string>

template <typename T>
concept Serializer = requires(const T& s, int v) {
    { s.serialize(v) } -> std::convertible_to<std::string>;
    { T::format_name } -> std::convertible_to<const char*>;
};

struct XmlSer {                                   // format_name을 빠뜨림
    std::string serialize(int v) const { return "<v>" + std::to_string(v) + "</v>"; }
};

void dump(const Serializer auto& s, int v) { (void)s.serialize(v); }

int main() { dump(XmlSer{}, 1); }

struct Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;
protected:                                        // 인터페이스 자체를 통한 복사·대입을 막는다
    Shape() = default;
    Shape(const Shape&) = default;
    Shape& operator=(const Shape&) = default;
};
struct Circle : Shape {
    double r = 1;
    double area() const override { return 3.14 * r * r; }
};

int main()
{
    Circle a, b;
    b.r = 2;
    a = b;                                        // 구체 타입끼리는 복사 가능
    Shape& ra = a;
    Shape& rb = b;
    ra = rb;                                      // 인터페이스 참조로 반쪽 대입은 금지
}