C 元妥儿编程中的蹦床

Question

我正在阅读一本关于元编程的书，并且在蹦床上有分裂：

struct generic_t
{
    void* obj;
    void(*del)(void*);
};
template <typename T> // outer template parameter
generic_t copy_to_generic(const T& value)
{
    struct local_cast // local class
    {
        static void destroy(void* p) // void*-based interface
        {
            delete static_cast<T*>(p); // static type knowledge
        }
    };
    generic_t p;
    p.obj = new T(value); // information loss: copy T* to void*
    p.del = &local_cast::destroy;
    return p;
}

我完全了解它的工作原理，但我不知道它的应用是什么！您通常在哪里使用此技术？剂量有人知道吗？谢谢：）

Answer 1

我在程序中的许多地方使用它。我喜欢这种方法的一件事是，您可以保留无关类型的列表。例如，我看到了很多看起来像这样的代码：

struct Abstract { virtual ~Abstract() = default; };
template<typename P>
struct AbstractHandler : Abstract {
    virtual void handle(P) = 0;
};
template<typename P, typename H>
struct Handler : AbstractHandler<P>, private H {
    void handle(P p) override {
        H::handle(p);
    }
};
struct Test1 {};
struct Test1Handler {
    void handle(Test1) {}
};
struct Test2 {};
struct Test2Handler {
    void handle(Test2) {}
};
int main() {
    std::vector<std::unique_ptr<Abstract>> handlers;
    handlers.emplace_back(std::make_unique<Handler<Test1, Test1Handler>>());
    handlers.emplace_back(std::make_unique<Handler<Test2, Test2Handler>>());
    // some code later....
    dynamic_cast<AbstractHandler<Test1>*>(handlers[0].get())->handle(Test1{});
    dynamic_cast<AbstractHandler<Test2>*>(handlers[1].get())->handle(Test2{});
}

动态铸件为程序增加了不必要的开销。相反，您可以像避免使用此开销的那样使用类型的seasure。

加上，Abstract甚至没有理由存在。这是一个没有实现功能的接口。这里真正的需要是保留无关接口的列表。

---

假设我们可以使用允许copy_to_generic将实例施加到父类。

。

template <typename Parent, typename T>
generic_t to_generic(T&& value) // forward is better.
{
    struct local_cast
    {
        static void destroy(void* p)
        {
            // we cast to the parent first, and then to the real type.
            delete static_cast<std::decay_t<T>*>(static_cast<Parent*>(p));
        }
    };
    generic_t p;
    p.obj = static_cast<Parent*>(new std::decay_t<T>(std::forward<T>(value)));
    p.del = &local_cast::destroy;
    return p;
}

使用" seal"类型查看此代码：

// No useless interface
template<typename P>
struct AbstractHandler {
   // No virtual destructor needed, generic_t already has a virtual destructor via `del`
    virtual void handle(P) = 0;
};
template<typename P, typename H>
struct Handler : private H {
    void handle(P p) override {
        H::handle(p);
    }
};
struct Test1 {};
struct Test1Handler {
    void handle(Test1) {}
};
struct Test2 {};
struct Test2Handler {
    void handle(Test2) {}
};
int main() {
    std::vector<generic_t> handlers;
    handlers.emplace_back(
        to_generic<AbstractHandler<Test1>>(Handler<Test1, Test1Handler>{})
    );

    handlers.emplace_back(
        to_generic<AbstractHandler<Test2>>(Handler<Test2, Test2Handler>{})
    );
    // some code later....
    static_cast<AbstractHandler<Test1>*>(handlers[0].obj)->handle(Test1{});
    static_cast<AbstractHandler<Test2>*>(handlers[1].obj)->handle(Test2{});
}

没有空的接口，也没有动态铸造！此代码与另一码相同，但更快。