Delete in C++ and garbage collection in Java

Question

Does delete in C++ work the same way as garbage collection in Java? I mean, the memory management part internally (what really happens in heap in both the cases?).

Answer 1

delete call in C++ releases memory on Free Store (heap) occupied by a variable using new operator. and we do all this manually (until we using smart pointers, C++ 11 and so on), for each new we must do corresponding delete. Garbage Collector is present only in C++ 11 and above. Garbage Collection in other languages (Java, C#) frees memory occupied by variable automatically. Behind the scene Garbage collector keeps reference count of variable and when reference count reaches 0 (or variable goes out of scope) it frees memory occupied by that variable.

Answer 2

In C++, the functionality of the delete, delete[], and new operators can be defined through operator overloading, so you can make it work however you want.

In Java's heap behavior is defined by the JVM, and in general, as long as no references to an object exist in memory, it will be cleared out by the garbage collector eventually. See this for more details on Java's garbage collection.

Answer 3

Actucally Garbage collection is automated . VM is automatically doing that. You can use System.gc() to force VM to do garbage collection.

Answer 4

Allocation and deallocation occurs on the heap. Let's take an example here. In C++ STL containers use an object called an allocator that does memory management. It allocates memory on the heap (lets assume it goes any random place that is not occupied) and then deallocates it. Now the allocator can have a map, or an array or some sort of data structure with which it can tell if there is some memory that is free, i.e. some memory that it has allocated and deallocated before. It can keep track of this itself, how it does this is implementation defined. All the programmer and the standard specify is that it just does this (and some restrictions therein) so as a programmer you should usually not worry about how heap allocation is done. The compiler can optimize code and make it behave differently in different situations.

Now going back to your question about delete in C++ and garbage collection in Java. C++ compiles down to raw machine executable code, i.e. code that is run natively by your machine (assembly code) while Java compiles down to "bytecode", "bytecode" is executed by the Java Virtual Machine (JVM), which itself is a program. delete in C++ makes the machine deallocates memory on the heap. In java delete happens automatically when an object doesn't have any references left to it and when garbage collection happens. The JVM here is like the allocator it "deallocates" memory.

So memory is marked deallocated. It can be reused. How that happens at machine level can vary extensively. You can even make the operators do what you want by overloading them! Hope that helps :)

Answer 5

In C++: new and delete are used to create and delete a "space". This space is mainly for storing your data. usually use stack to store some return value, local variables, function parameters and so on, heap is another space that usually created by programmers. However, there are others space like static which is used to store global variables and static value or constant. In C, we usually use malloc/free, In C++ we use new/delete, you should know malloc() just is a function but new() is a constructor.

Time *t;

t = new Time(0,0,0,/"t");//this allowed you create a space in heap by using constructor

now there is a space in heap and p is point at this address.

delete t;// this delete is used to delete the pointer, which means this space won't be used anymore, after a short time, C++ will recycle this space.

JAVA: In java you should know JVM and GC. JVM has 5 parts:

1. program counter(used by thread)
2. VM stack(store primary variables and so on)
3. native method are(OS method)
4. Method are(contain runtime constant pool)
5. HEAP !!!(GC mainly works here)

In JVM, there are mainly three parts in JVM's heap:

• Eden or young generation(used to store the latest created object)
• Tenuerd (old) generation(used to store some objects which is always used)
• permanent generation(after Jdk 8 version it's merged into old generation) Anyway, hope you have some idea about java heap, if not, you should now most objects created and store in there.

• How GC work: first user create a object

  Object o = new Object();

• o has a address and is stored in heap(usually object has 8 bytes for identify such as class information), at the very beginning, it store in young generation, there are two register call "from" and "to" in young generation which are identical. we have o now, there is a counter of this object, we create it the counter is 1, next time it used, the counter goes to 2, when counter change young generation will wipe the others objects(not activated objects), o will be stored in "from", next time objects in register "from" will be copied to "to",until the counter increased to 8, it will be copied to on generation.

• old generation use mark and wipe algorithm. The first step in the process is called marking. This is where the garbage collector identifies which pieces of memory are in use and which are not. Second is Normal delete,normal deletion removes unreferenced objects leaving referenced objects and pointers to free space.To further improve performance, in addition to deleting unreferenced objects, you can also compact the remaining referenced objects. By moving referenced object together, this makes new memory allocation much easier and faster. So far, the heap use this strategy, it can clean it memory and keep objects which is always been used.

Any suggestion is welcomed and appreciate, hope it can help you understand.