C++备忘录001：对用户隐藏多态

隐藏多态细节，用户看到的只是一个concrete class，思想来自于Better Code: Runtime Polymorphism - Sean Parent

以下代码直到gcc 9.2编译会通过，但是运行会出现段错误，在model的构造函数列表中data_{std::move(t)}会被gcc解释成构造列表，此行为似乎与标准相悖，必须改成data_(std::move(t))，强制gcc使用拷贝构造函数才行。clang无此问题

#include <algorithm>
#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <future>
#include <chrono>

template <typename T>
void draw(const T &x, std::ostream &out, std::size_t pos) {
    out << std::string(pos, ' ') << x << std::endl;
}

class object_t final {
    public:
        template <typename T> object_t(T x) : self_(std::make_shared<model<T>>(std::move(x))) {}

        friend void draw(const object_t &t, std::ostream &out, std::size_t pos) {
            t.self_->draw_(out, pos);
        }
    private:
        struct concept_t {
            virtual ~concept_t() = default;
            virtual void draw_(std::ostream &out, std::size_t pos) const = 0;
        };

        template <typename T> struct model final : concept_t {
            model(T t): data_{std::move(t)} {}
            void draw_(std::ostream &out, std::size_t pos) const override {
                draw(data_, out, pos);
            }
            T data_;
        };
        std::shared_ptr<const concept_t> self_;
};

struct my_class_t {};

void draw(const my_class_t &, std::ostream &out, std::size_t pos) {
    out << std::string(pos, ' ') << "my_class_t\n";
}

using document_t = std::vector<object_t>;

void draw(const document_t &document, std::ostream &out, std::size_t pos) {
    out << std::string(pos, ' ') << "<document>\n";
    for_each(begin(document), end(document), [&out, pos](const auto &i) { draw(i, out, pos + 2); }); 
    out << std::string(pos, ' ') << "</document>\n";
}

using history_t = std::vector<document_t>;
void commit(history_t &h) { h.push_back(h.back()); }
void undo(history_t &h) { h.pop_back(); }
document_t &current(history_t &h) { return h.back(); }

int main() {
    history_t h(1);
    current(h).reserve(6);

    current(h).emplace_back(3);
    current(h).emplace_back(std::string("Hello"));

    draw(current(h), std::cerr , 0);
    std::cerr << "----------------------------------\n";

    commit(h);
    current(h)[0] = 45.1;
    current(h)[1] = "World";
    auto f = std::async(std::launch::async, [document=current(h)]{
            std::cerr << "------------ save ----------------\n";
            std::this_thread::sleep_for(std::chrono::seconds(3));
            draw(document, std::cerr, 0);
    });
    current(h).emplace_back(current(h));
    current(h).emplace_back(my_class_t{});

    draw(current(h), std::cerr, 0);
    std::cerr << "----------------------------------\n";

    undo(h);
    draw(current(h), std::cerr, 0);
}

亦可用std::unique_ptr实现

class object_t final {
    public:
        template <typename T> object_t(T x) : self_(std::make_unique<model<T>>(std::move(x))) { std::cerr << "ctor\n"; }
        object_t(const object_t &t) : self_(t.self_->copy_()) { std::cerr << "copy\n"; }
        object_t(object_t &&t) = default;
        object_t &operator=(const object_t &t) { std::cerr << "=\n"; return *this = object_t(t); }
        object_t &operator=(object_t &&t) = default;

        friend void draw(const object_t &t, std::ostream &out, std::size_t pos) {
            t.self_->draw_(out, pos);
        }
    private:
        struct concept_t {
            virtual ~concept_t() = default;
            virtual std::unique_ptr<const concept_t> copy_() const = 0;
            virtual void draw_(std::ostream &out, std::size_t pos) const = 0;
        };

        template <typename T> struct model final : concept_t {
            model(T t): data_(std::move(t)) {}
            std::unique_ptr<const concept_t> copy_() const override { return std::make_unique<model<T>>(data_); }
            void draw_(std::ostream &out, std::size_t pos) const override {
                draw(data_, out, pos);
            }
            T data_;
        };
        std::unique_ptr<const concept_t> self_;
};