C++ 如何从成员函数中释放对象？

今天我有一个测试类，它注册了一个工厂函数来构造对象。因为我需要在脚本引擎中嵌入这个对象。因此，工厂函数负责为对象分配内存并创建测试类的实例

对象是引用计数的，因此当计数器达到0时，它必须自毁并释放工厂函数分配的内存。它必须通过一个成员函数来实现

这是我试图做的一个例子：

#include <memory>
#include <cstdio>

class Test
{
public:
    typedef std::allocator<Test> Allocator;

    Test()
        : m_Ref(1)
    {
        // Constructing....
    }

    ~Test()
    {
        // Destructing....
    }

    static Test *Create()
    {
        Allocator::pointer ptr = 0;
        Allocator alloc;

        try
        {
            ptr = alloc.allocate(1);
            alloc.construct(ptr);
        }
        catch (const std::bad_alloc &ba)
        {
            // Propagate the error message to the script engine...
        }
        catch (...)
        {
            alloc.deallocate(ptr, 1);
            ptr = 0;
            // Propagate the error message to the script engine...
        }

        return ptr;
    }

    void AddRef()
    {
        m_Ref++;
    }
    void SubRef()
    {
        if (--m_Ref == 0)
        {
            Allocator alloc;
            alloc.destroy(this);
            alloc.deallocate(this, 1);
        }
    }
    int RefSum()
    {
        return m_Ref;
    }
private:
    mutable int m_Ref;
};

int main(int argc, char** argv)
{
    // Script would call
    Test *ptr = Test::Create();

    // Use the object (as an example)
    printf("Ref count is: %d\n", ptr->RefSum());

    // Now to release
    ptr->SubRef();

    // The object must not exist now...
    printf("Ref count is: %d\n", ptr->RefSum());

    return 0;
}

#包括
#包括
课堂测试
{
公众：
typedef std:：分配器分配器；
测试（）
：m_Ref（1）
{
//建造。。。。
}
~Test（）
{
//破坏。。。。
}
静态测试*Create（）
{
分配器：：指针ptr=0；
分配程序alloc；
尝试
{
ptr=分配分配（1）；
分配构造（ptr）；
}
捕获（常数标准：：错误分配和ba）
{
//将错误消息传播到脚本引擎。。。
}
捕获（…）
{
分配解除分配（ptr，1）；
ptr=0；
//将错误消息传播到脚本引擎。。。
}
返回ptr；
}
void AddRef（）
{
m_Ref++；
}
void SubRef（）
{
如果（--m_Ref==0）
{
分配程序alloc；
破坏（这个）；
分配-解除分配（本，1）；
}
}
int RefSum（）
{
返回m_Ref；
}
私人：
可变整数m_Ref；
};
int main（int argc，字符**argv）
{
//脚本将调用
Test*ptr=Test:：Create（）；
//使用对象（作为示例）
printf（“引用计数为：%d\n”，ptr->RefSum（））；
//现在发布
ptr->SubRef（）；
//对象现在不能存在。。。
printf（“引用计数为：%d\n”，ptr->RefSum（））；
返回0；
}

所以我的问题是：当m_Ref达到0并且对象被销毁和释放时，之前分配的内存是否被释放

如果没有，那么当m_Ref达到0时，如何释放用std:：allocator:：allocate（）分配的内存。

所以我的问题是：当m_Ref达到0并且对象被销毁和释放时，以前分配的内存是否被释放

---

答案很简单：是的。“免费”和“取消分配”的意思是一样的。

您是否考虑过使用

std:：shared\u ptr

？您的代码还可以，包括

ptr->SubRef（）

调用。有一个

allocate

调用和一个匹配的

deallocate

调用。没有内存泄漏。但是，随后的

ptr->RefSum（）

调用显示了未定义的行为-您正在调用对象的方法，该方法的生命周期已结束。我不太理解这个问题。您是否询问

alloc.deallocate（这个，1）释放内存？是的。显然。你真的能用一个与你分配给它的对象不同的
std:：allocator
对象来释放一个对象吗？@Barmar，是的。对于所有
X
，类型为
std:：allocator
的所有对象都是等效的。