Inheritance Is The Base Class of Evil

链接

#include "pch.h"

#include <cassert>
#include <iostream>
#include <stack>
#include <vector>

using namespace std;

struct my_struct_t
{
};

void draw(const my_struct_t& x, ostream& out, size_t pos)
{
    out << string(pos, ' ') << "my_struct_t" << endl;
}

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

class object_t
{
public:
    template <typename T>
    object_t(T x) : self_(std::make_shared<model<T>>(std::move(x)))
    {
        cout << "ctor" << endl;
    }

    //object_t(const object_t& x) : self_(x.self_->copy_())
    //{
    //  cout << "copy" << endl;
    //}

    //object_t(object_t&&) noexcept = default;

    //object_t& operator=(const object_t& x)
    //{
    //  object_t tmp(x);
    //  *this = std::move(tmp);
    //  return *this;
    //}

    //object_t& operator=(object_t&&) noexcept = default;

    friend void draw(const object_t& x, ostream& out, size_t pos)
    {
        x.self_->draw_(out, pos);
    }

private:

    struct concept_t
    {
        virtual ~concept_t() = default;
        //  virtual concept_t* copy_() const = 0;
        virtual void draw_(ostream&, size_t) const = 0;
    };

    template <typename T>
    struct model : concept_t
    {
        model(T x) : data_(std::move(x))
        {
        }

        //concept_t* copy_() const override { return new model(*this); }

        void draw_(ostream& out, size_t pos) const override
        {
            draw(data_, out, pos);
        }

        T data_;
    };

    shared_ptr<const concept_t> self_;
};

using document_t = vector<object_t>;

void draw(const document_t& x, ostream& out, size_t pos)
{
    out << string(pos, ' ') << "<document>" << endl;
    for (auto& e : x)
        draw(e, out, pos + 2);
    out << string(pos, ' ') << "</document>" << endl;
}

using history_t = vector<document_t>;

void commit(history_t& x)
{
    assert(x.size());
    x.push_back(x.back());
}

void undo(history_t& x)
{
    assert(x.size());
    x.pop_back();
}

document_t& current(history_t& x)
{
    assert(x.size());
    return x.back();
}

void main()
{
    //document_t doc;

    //doc.emplace_back(0);
    //doc.emplace_back(1);
    //doc.emplace_back(doc);
    //doc.emplace_back(2);
    //doc.emplace_back(3);
    //doc.emplace_back(my_struct_t());

    //draw(doc, cout, 0);


    history_t h(1);

    current(h).emplace_back(0);
    current(h).emplace_back("hello");

    draw(current(h), cout, 0);

    cout << "-------------------------------------------" << endl;

    commit(h);

    current(h).emplace_back(current(h));
    current(h).emplace_back(my_struct_t());
    current(h)[1] = string("World");

    draw(current(h), cout, 0);

    cout << "-------------------------------------------" << endl;

    undo(h);

    draw(current(h), cout, 0);
}