Blog

#include <cstdio>
#include <string>

// 프로그램마다 똑같이 반복되는 뼈대
int main(int argc, char** argv)
{
    std::printf("  load config, init log\n");      // 공통 초기화
    std::string who = argc > 1 ? argv[1] : "world";
    std::printf("  hello, %s\n", who.c_str());    // 실제로 프로그램마다 다른 부분은 이것뿐
    std::printf("  flush log, cleanup\n");         // 공통 정리
    return 0;
}

#pragma once
#include <string>
#include <vector>

class Application {
    static inline Application* the_app_ = nullptr;
    friend int main(int, char**);
protected:
    std::vector<std::string> args;
public:
    Application() { the_app_ = this; }            // 전역 객체 생성 시 자신을 등록
    virtual ~Application() = default;
    virtual bool init_instance() { return true; } // 사용자가 재정의할 지점들
    virtual int run() = 0;
    virtual void exit_instance() {}
};

#include <cstdio>
#include "framework.h"

int main(int argc, char** argv)                   // main은 프레임워크가 가진다
{
    Application* app = Application::the_app_;
    if (!app) { std::fprintf(stderr, "  no application object\n"); return 1; }
    app->args.assign(argv + 1, argv + argc);
    std::printf("  [fw] init log/config\n");
    int rc = 1;
    if (app->init_instance()) rc = app->run();
    else std::printf("  [fw] init_instance failed\n");
    app->exit_instance();
    std::printf("  [fw] cleanup, rc=%d\n", rc);
    return rc;
}

#include <cstdio>
#include "framework.h"

class HelloApp : public Application {             // main 없이 할 일만 작성
    int run() override
    {
        std::printf("  hello, %s\n", args.empty() ? "world" : args[0].c_str());
        return 0;
    }
};
HelloApp theApp;                                  // 전역 객체 하나

#include <cstdio>
#include <cstdlib>
#include "framework.h"

class CalcApp : public Application {
    bool init_instance() override
    {
        if (args.size() != 2) { std::printf("  usage: calc A B\n"); return false; }
        return true;
    }
    int run() override
    {
        std::printf("  %s + %s = %d\n", args[0].c_str(), args[1].c_str(), std::atoi(args[0].c_str()) + std::atoi(args[1].c_str()));
        return 0;
    }
    void exit_instance() override { std::printf("  calc: bye\n"); }
};
CalcApp theApp;

#include <cstdio>

struct Application {
    Application() { std::printf("  in base ctor: "); name(); }   // 여기서 가상 함수를 부르면?
    virtual ~Application() = default;
    virtual void name() { std::puts("Application"); }
};
struct MyApp : Application {
    void name() override { std::puts("MyApp"); }
};

int main()
{
    MyApp a;
    std::printf("  after ctor:   ");
    a.name();
}

#pragma once
#include <memory>

struct Application {
    virtual ~Application() = default;
    virtual int run() = 0;
};

std::unique_ptr<Application> create_app();        // 사용자 쪽이 정의할 팩토리 함수

// wxWidgets IMPLEMENT_APP과 같은 방식: 전역 객체 대신 팩토리 함수를 정의하는 매크로
#define IMPLEMENT_APP(T) \
    std::unique_ptr<Application> create_app() { return std::make_unique<T>(); }

#include <cstdio>
#include "fw2.h"

int main()
{
    std::printf("  [fw2] logging ready\n");       // 프레임워크 준비가 끝난 뒤에 생성
    auto app = create_app();
    int rc = app->run();
    std::printf("  [fw2] rc=%d\n", rc);
    return rc;
}

#include <cstdio>
#include "fw2.h"

struct MyApp : Application {
    MyApp() { std::printf("  MyApp ctor\n"); }
    int run() override { std::printf("  MyApp run\n"); return 0; }
};
IMPLEMENT_APP(MyApp)

#include "fw2.h"
struct OtherApp : Application { int run() override { return 0; } };
IMPLEMENT_APP(OtherApp)