About Garbage collection in C++

Question

I am reading about the Garbage Collector pattern. It was mentioned that this architectural pattern removes the vast majority of memory related problems by effectively eliminating memory leaks and dangling pointers.

I understand that using a Garbage Collector can remove memory leaks, but how can the Garbage Collector address the issue of dangling pointers? Please give me an example of how problems with dangling pointers can be solved using a Garbage Collector, assuming I am implementing it using a mark and sweep algorithm.

Thanks!

Answer 1

A dangling pointer arises when you use the address of an object after its lifetime is over. This may occur in situations like returning addresses of the automatic variables from a function or using the address of the memory block after it is freed. The following code snippet shows this:

class Sample
{
public:
        int *ptr;
        Sample(int i)
        {
            ptr = new int(i);
        }

        ~Sample()
        {
            delete ptr;
        }
        void PrintVal()
        {
            cout << "The value is " << *ptr;
        }
};

void SomeFunc(Sample x)
{
    cout << "Say i am in someFunc " << endl;
}

int main()
{
    Sample s1 = 10;
    SomeFunc(s1);
    s1.PrintVal();
}

In the above example when PrintVal() function is called it is called by the pointer that has been freed by the destructor in SomeFunc.

Answer 2

The problem of dangling pointers is handled indirectly: in a GC environment, an object is only deleted when there are no pointers that refer to the object, and as such it will not be deleted in any case where it would leave a dangling pointer. That is, there will be no dangling pointers at all, and the problem cannot occur.