Question

假设我声明了这样的类：

foo.h中

namespace foo
{
    class Data
    {
    public:
        void reatain();
        void release()
        {
            _refCnt--;
            if(_refCnt == 0) _alloc->dealloc(_data);
        }

        int _refCnt;
        Allocator *_alloc;
        void *_data;
    };

    class Example
    {
    public:
        // some functions

        Data *_data;
    };
}

bar.h

namespace bar
{
    class Data
    {
        // declare the same with foo
    };

    class Example
    {
    public:
        // some functions

        /* except casting to foo::Example operator*/
        operator foo::Example() const
        {
            foo::Example fooex;
            fooex._data = reinterpret_cast<foo::Data *>(this->_data);
            return fooex;
        }
    };
}

的main.cpp

#include <foo.h>
#include <bar.h>

int main(void)
{
    bar::Example barex;
    foo::Example fooex = static_cast<foo::Example>(barex);

    // do smt

    return 0;
}

所有类都在同一主机，arch，编译器等中编译。

我想知道这个实现，其中是否有任何隐藏的错误。

当foo：示例被解除分配。 foo认为他的Data *是foo::Data *但实际上是bar::Data *。然后它调用_data->release()。

如果我按照这样的方式实施，我不知道是否有任何问题

我不知道编译器是如何做的。

宣布2个类相同。因此，如果将bar::Data用作foo:Data？

，有一天它们会导致错误

Answer 1

我的意见是，代码很脆弱，但应该有效。我在印象领域下订购和包装基本上是一致的，但我不相信它实际上是C ++规范的东西。

更实际的是，传统的malloc / free只运行指针基地址。此外，由于您没有虚拟析构函数，因此您的dealloc阶段非常简单，不会出现问题。我无法评论RTTI可能产生的影响，我从未在该领域获得过知识，但值得考虑。

需要指出的是，您尚未确定方法根本不适用于你。我的期望是你的传统行为。

从类转换为类c ++

1 个答案: