没有句柄的动态分配变量会发生什么？ (C++)

Question

像这样实例化没有句柄的类会导致 C++ 中的 memory 泄漏吗？

new SomeClass();

在方法中传递它们怎么样？

SomeMethod(new SomeClass())

在方法的定义超出 scope 之后，它们会被释放吗？

这听起来像是一个愚蠢的问题，但据我所知，如果他们不被释放，他们哪儿也去不了。

Answer 1

是的，你是对的。 默认 C++，每次调用new后都必须跟delete ，否则就是 leak。 但是，在某些边缘情况下，可以在不使用delete的情况下使用new 。

一种这样的情况是placement new ，其中 memory 分配由您自己处理。 例子：

#include <cstdint>
#include <memory>
#include <iostream>

struct X {
    int a;
    int b;
};

int main(int argc, char** argv) {

    char buffer[256];

    X* x1 = new (&buffer[0]) X{1,2};
    X* x2 = new (&buffer[8]) X{3,4};

    std::cout << "x1: " << x1->a << " " << x1->b << std::endl;
    std::cout << "x2: " << x2->a << " " << x2->b << std::endl;

    // no leaks since the memory is released when `buffer` is 
    // deallocated. However it is good practice to call the 
    // destructor directly
    x1->~X();
    x2->~X();
}

产生：

Program stdout
x1: 1 2
x2: 3 4

Godbolt: https://godbolt.org/z/sEPWadcKh

另一种情况是当 class覆盖 operator new时，如本例所示：

#include <cstdint>
#include <memory>
#include <iostream>

static char buffer[32768];
static char* ptr = &buffer[0];

struct X {
    int a;
    int b;
    void* operator new(size_t size) {
        void* p = ptr;
        ptr += size;
        return p;
    }
    void operator delete(void*) {
        // no need to do anything
    }
};

int main(int argc, char** argv) {

    X* x1 = new X{1,2};
    X* x2 = new X{3,4};

    std::cout << "x1: " << x1->a << " " << x1->b << std::endl;
    std::cout << "xs: " << x2->a << " " << x2->b << std::endl;

    // no leaks since the memory is released when `buffer` is 
    // deallocated. However it is good practice to call the 
    // destructor directly
    x1->~X();
    x2->~X();
}

产生：

Program stdout
x1: 1 2
x2: 3 4

Godbolt: https://godbolt.org/z/jc4r9qbxh

另一种情况是当您将new与智能指针一起使用时，如下例所示

#include <cstdint>
#include <memory>
#include <iostream>
#include <boost/intrusive_ptr.hpp>

struct X {
    X(int a_, int b_ ) : a(a_), b(b_){
        std::cout << "Constructor " << this << std::endl;
    }
    ~X() {
        std::cout << "Destructor " << this << std::endl;
    }
    int a;
    int b;
    int count = 0;
};

void intrusive_ptr_add_ref(X* x)
{
    ++x->count;
}

void intrusive_ptr_release(X* x)
{
    if (--x->count == 0)
        delete x;
}

int main(int argc, char** argv) {

    boost::intrusive_ptr<X> x1 = new X{1,2};
    boost::intrusive_ptr<X> x2 = new X{3,4};

    std::cout << "x1: " << x1->a << " " << x1->b << std::endl;
    std::cout << "x2: " << x2->a << " " << x2->b << std::endl;
}

产生：

Constructor 0xb4b2b0
Constructor 0xb4c2e0
x1: 1 2
x2: 3 4
Destructor 0xb4c2e0
Destructor 0xb4b2b0

Godbolt： https://godbolt.org/z/b7MTfazT9

因此，虽然delete是代表您调用的，但作为用户的您不必自己调用delete 。

另一个用例是为管理对象生命周期的框架创建对象，如Qt 。

所以答案确实是肯定的，总是在new之后调用delete ，但在行业中有很多情况并不是真的有必要。