C ++新的运算符用法问题

Question

I just accidentally write the code below. It is compiled using gcc 4.4.7 in linux environment.

int main ()
{
        new int;
        return 0;
}

I am surprised the compiler does not indicate any error or warning. Is the c++ standard mentioned about this? Is it still possible to prevent memory leak in this situation? Any advice is welcome.

Answer 1

There is no problem with this. This is valid in c++.

Answer 2

This is perfectly valid C++. Why are you surprised that it compiled?

Answer 3

To prevent memory leaks you should use shared_ptr instead of raw pointers:

#include <memory>
int main ()
{
        std::shared_ptr<int> i(new int);
        return 0;
}

Now the new allocated object is deleted at the end of the scope. And you do not have a memory leak in you code. For more details have a look at the dynamic memory management of C++11 Dynamic Memory management

Answer 4

This is one reason why you should try to avoid raw "new" as much as possible in new code. std::make_shared and in c++14 std::make_unique are much safer as they will ensure that memory gets deleted properly by returning shared_ptr and unique_ptr objects that know when and how to delete the object. The intention is that raw new will mostly only be needed in low level code implementing data structures.

Answer 5

As I commented, a program can "legitimately" leak memory.

On most operating systems (notably Posix or Linux), the kernel will release all the memory used by a process after the process exits .

So if during its initialization, a program allocates some (heap) data -in limited quantity- and don't bother releasing it at all, it is a "legitimate" memory leak (and may real programs exhibit that behavior: eg the GCC compiler, or Firefox browser, or most X11 client libraries, etc...).

However, leaks which happen continuously during the normal operation of the program and which increase the memory consumption are frowned upon.

Also, I believe that it can be proven that static analysis of memory leaks is equivalent to the halting problem so there is no way to always detect it at compile time: either you'll get some false alarms , or some leaks will stay undetected.

At runtime, you could use valgrind to chase memory leaks.

Also, the liveness of some memory zone is a global property of the program. Read more about garbage collection and perhaps consider using Boehm's conservative GC .