Memory leak in Return

Question

I’m reading a book and I came across this code:

class SimpleCat
{
    public:
    SimpleCat (int age, int weight);
    ~SimpleCat() {}
    int GetAge() { return itsAge; }
    int GetWeight() { return itsWeight; }

    private:
    int itsAge;
    int itsWeight;
};

SimpleCat::SimpleCat(int age, int weight):
itsAge(age), itsWeight(weight) {}

SimpleCat & TheFunction();

int main()
{
    SimpleCat & rCat = TheFunction();
    int age = rCat.GetAge();
    cout << "rCat is " << age << " years old!\n";
    cout << "&rCat: " << &rCat << endl;
    // How do you get rid of that memory?
    SimpleCat * pCat = &rCat;
    delete pCat;
    // Uh oh, rCat now refers to ??
    return 0;
}

SimpleCat &TheFunction()
{
    SimpleCat * pFrisky = new SimpleCat(5,9);
    cout << "pFrisky: " << pFrisky << endl;
    return *pFrisky;
}

My question is:

The book says there’s a memory leak in retun of the call for SimpleCat & rCat = TheFunction() due to memory allocation in scope. I wondered how to solve this.

Answer 1

The function TheFunction does the following:

SimpleCat * pFrisky = new SimpleCat(5,9);

This line dynamically allocates an instance of the class SimpleCat, points your memory address to the variable (pointer) pFrisky and returns that memory address as a reference.

Already out on the call of main, the function TheFunction was called so:

SimpleCat & rCat = TheFunction();

So that dynamically created instance is now being referenced at another address, defined in a non-dynamic way in the variable rCat (who, note, is not a pointer).

Both of the calls below print the memory address where the object is located:

1. cout << "pFrisky: " << pFrisky << endl (in function TheFunction)
2. cout << "&rCat: " << &rCat << endl; (in function main)

I didn’t run to be sure, but you’ll probably realize that they are different addresses (because the second variable, rCat, was not dynamically allocated.

Edit: I ran it in Ideone to have certainty, and not necessarily the printed addresses shall be different. Still, objects are allocated in different places (read about the difference between the heap and stack right here), and for that the leak.

So when you try to delete that dynamically allocated area by doing:

SimpleCat * pCat = &rCat;
delete pCat;

In fact you’re making a beautiful of a cag... I mean, nonsense. :)

How to solve? If you allocate dynamically, return an actual pointer:

SimpleCat *TheFunction()
{
    SimpleCat * pFrisky = new SimpleCat(5,9);
    cout << "pFrisky: " << pFrisky << endl;
    return pFrisky;
}

There, in the main, you do:

SimpleCat * rCat = TheFunction();
. . .
delete rCat;