C++ 中不同大小的不同行为（火息源代码）

Question

当我查看 firebreath 的源代码时遇到一个困惑的问题（ src/ScriptingCore/Variant.h）

    // function pointer table
    struct fxn_ptr_table {
        const std::type_info& (*get_type)();
        void (*static_delete)(void**);
        void (*clone)(void* const*, void**);
        void (*move)(void* const*,void**);
        bool (*less)(void* const*, void* const*);
    };

    // static functions for small value-types 
    template<bool is_small>
    struct fxns
    {
        template<typename T>
        struct type {
            static const std::type_info& get_type() { 
                return typeid(T); 
            }
            static void static_delete(void** x) { 
                reinterpret_cast<T*>(x)->~T(); 
            }
            static void clone(void* const* src, void** dest) { 
                new(dest) T(*reinterpret_cast<T const*>(src)); 
            }
            static void move(void* const* src, void** dest) { 
                reinterpret_cast<T*>(dest)->~T(); 
                *reinterpret_cast<T*>(dest) = *reinterpret_cast<T const*>(src); 
            }
            static bool lessthan(void* const* left, void* const* right) {
                T l(*reinterpret_cast<T const*>(left));
                T r(*reinterpret_cast<T const*>(right));

                return l < r;
            }
        };
    };

    // static functions for big value-types (bigger than a void*)
    template<>
    struct fxns<false>
    {
        template<typename T>
        struct type {
            static const std::type_info& get_type() { 
                return typeid(T); 
            }
            static void static_delete(void** x) { 
                delete(*reinterpret_cast<T**>(x)); 
            }
            static void clone(void* const* src, void** dest) { 
                *dest = new T(**reinterpret_cast<T* const*>(src)); 
            }
            static void move(void* const* src, void** dest) { 
                (*reinterpret_cast<T**>(dest))->~T(); 
                **reinterpret_cast<T**>(dest) = **reinterpret_cast<T* const*>(src); 
            }
            static bool lessthan(void* const* left, void* const* right) {
                return **reinterpret_cast<T* const*>(left) < **reinterpret_cast<T* const*>(right);
            }
        };
    };

    template<typename T>
    struct get_table 
    {
        static const bool is_small = sizeof(T) <= sizeof(void*);

        static fxn_ptr_table* get()
        {
            static fxn_ptr_table static_table = {
                fxns<is_small>::template type<T>::get_type
                , fxns<is_small>::template type<T>::static_delete
                , fxns<is_small>::template type<T>::clone
                , fxns<is_small>::template type<T>::move
                , fxns<is_small>::template type<T>::lessthan
            };
            return &static_table;
        }
    };

问题是为什么大值类型（大于 void*）的静态函数的实现与小值类型不同。

例如，对于小值类型，static_delete 只是调用 T 实例的析构函数，而对于大值类型，则使用“删除”。

有什么技巧吗？提前致谢。

Answer 1

看起来Firebreath为其小对象使用了专用的内存池，而大对象通常在堆中分配。因此有不同的行为。例如，请注意 clone() 中小对象的 new 位置：这会在指定的内存位置创建新对象，而不分配它。当您使用放置new创建对象时，必须在释放内存之前显式调用其析构函数，这就是static_delete()所做的。

内存实际上并未被释放，因为正如我所说，它看起来像是正在使用专用的内存池。内存管理必须在其他地方执行。这种内存池是常见的针对小对象的优化。

Answer 2

内部文档怎么说？如果作者没有
记录下来，他可能不认识自己。

从代码来看，小对象的接口与
对于大型物体；您为小对象传递的指针是
指向对象本身的指针，其中作为一个大对象传递的指针
object 是一个指向该对象的指针。

然而，作者似乎不太了解 C++（我会
避免使用这样的代码）。例如，在 move 中，他明确地
破坏对象，然后分配给它：这保证是未定义的
行为，除了最简单的情况之外，可能无法可靠地工作
内置类型。小物体与大物体的区别很大程度上是
不相关的；一些“小”物体的成本可能相当高
复制。当然，考虑到这里的一切都是模板，
绝对没有理由使用 void* 来做任何事情。

Answer 3

我已经编辑了您的问题以包含原始源文件的链接，因为显然这里回答的大多数人都没有阅读它以了解实际发生的情况。我承认这可能是 FireBreath 中最令人困惑的代码之一；当时，我试图避免使用 boost，这非常有效。

从那时起，我考虑切换到 boost::any （对于那些渴望建议它的人，不，boost::variant 不起作用，我不会在这里解释为什么；如果你真的关心，请问另一个问题）但是我们对这个类进行了相当多的定制，以使其完全符合我们的需要，而 boost::any 很难以类似的方式定制。最重要的是，我们一直遵循古老的格言：如果它没有坏，就不要修理它！

首先，你应该知道有几位 C++ 专家已经审阅过这段代码；是的，它使用了一些许多人认为可疑的做法，但它们经过了非常仔细的考虑，并且它们在 FireBreath 支持的编译器上是一致且可靠的。我们已经使用 valgrind、视觉泄漏检测器、LeakFinder 和 Rational Purify 进行了广泛的测试，并且从未在该代码中发现任何泄漏。这有点令人困惑；令我惊讶的是，不懂代码的人会认为作者不懂 C++。在这种情况下，Christopher Diggins（他编写了您引用的代码以及原始的 cdiggins::any 类）似乎非常了解 C++，他能够编写此代码这一事实证明了这一点。该代码在内部使用并且经过高度优化——实际上可能超出了 FireBreath 的需要。然而，它对我们很有帮助。

我将尽力以我所记得的最好方式解释你的问题的答案；请记住，我没有太多时间，而且我已经有一段时间没有真正深入研究这个问题了。 “小”类型使用不同静态类的主要原因是“小”类型几乎是内置类型； int、char、long 等。任何大于 void* 的东西都被假定为某种类型的对象。这是一种优化，允许它尽可能重用内存，而不是删除并重新分配内存。

如果你并排查看代码，就会清楚得多。如果您查看删除和克隆，您会发现在“大”对象上它会动态分配内存；它在删除中调用“删除”，在克隆中它使用常规的“新”。在“小”版本中，它只是在内部存储内存并重用它；它永远不会“删除”内存，它只是在其内部拥有的内存上调用正确类型的析构函数或构造函数。再次强调，这样做只是为了提高效率。在两种类型上的移动中，它都会调用旧对象的析构函数，然后分配新对象数据。

对象本身存储为 void* 因为我们实际上不知道该对象是什么类型；事实上，要获取对象，您必须指定类型。这是允许容器保存绝对任何类型的数据的一部分。这就是那里有如此多的reinterpret_cast调用的原因——很多人看到这一点并说“哦，不！作者一定是一无所知！”但是，当您需要取消引用 void* 时，这正是您要使用的运算符。

不管怎样，综上所述，cdiggins 今年实际上已经推出了他的任何课程的新版本；我需要看一下它，并且可能会尝试将其替换为当前的。诀窍是我已经定制了当前版本（主要是添加一个比较运算符，以便可以将其放入 STL 容器中并添加 Convert_cast），因此我需要确保我足够了解新版本，以便安全地执行此操作。

希望有帮助；我从中得到的文章在这里： http://www.codeproject.com/KB/ cpp/dynamic_typing.aspx

请注意，该文章已更新，似乎无法再使用原始文章来访问旧文章。

编辑

自从我写这篇文章以来，我们已经确认了旧变体类的一些问题，并且它已被更新并替换为利用 boost::any 的变体类。感谢 dougma 在这方面所做的大部分工作。 FireBreath 1.7（截至撰写本文时的当前主分支）包含该修复。