Returning References to Objects - c++

Question

I would like some help in returning references to objects created in the heap.
I am reading a book titled Sam's Teach Yourself C++ and in chapter 12, the author introduces returning references to objects on the heap. The example illustrates a memory leak, and the author says that one of the solutions is to declare the object in the calling function and then to pass it to TheFunction() by reference.
This is the example:
// Listing 12.5
// Resolving memory leaks
#include <iostream>
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();
std::cout << "rCat is " << age << " years old!\n";
std::cout << "&rCat: " << &rCat << std::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);
std::cout << "pFrisky: " << pFrisky << std::endl;
return *pFrisky;
}
My attempt:
#include <iostream>
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(SimpleCat&);
int main()
{
SimpleCat * rCat;
rCat = TheFunction(rCat);
int age = rCat->GetAge();
std::cout << "rCat is " << age << " years old!\n";
std::cout << "rCat: " << rCat << std::endl;
delete rCat;
rCat = 0;
system("PAUSE");
return 0;
}
SimpleCat* TheFunction(SimpleCat& rCat)
{
rCat = new SimpleCat(5, 9);
std::cout << "rCat: " << rCat << std::endl;
return rCat;
}
Second Attempt
#include <iostream>
using namespace std;
class SimpleCat
{
public:
SimpleCat(int age, int weight)
{
}
void setAge(int age)
{
itsAge = age;
}
void setWeight(int wgt)
{
itsWeight = wgt;
}
~SimpleCat() { cout << "Object is being deleted" << endl; }
int GetAge() { return itsAge; }
int GetWeight() { return itsWeight; }
private:
int itsAge;
int itsWeight;
};
//SimpleCat * TheFunction();
SimpleCat& TheFunction(SimpleCat* rCat)
{
rCat = new SimpleCat(5,9);
//pFrisky->setAge(5);
//pFrisky->setWeight(9);
return *rCat;
}
int main()
{
SimpleCat * rCat;
SimpleCat & rCat = TheFunction(&rCat);
int age = rCat.GetAge();
std::cout << "rCat is " << age << " years old!\n";
system("PAUSE");
return 0;
}

Answer 1

This could work (in the sense, compile), but is actually wrong:
SimpleCat TheFunction()
{
rCat = new SimpleCat(5,9);
// do something with rCat if you want
return *rCat;
}
int main()
{
SimpleCat rCat = TheFunction();
int age = rCat.GetAge();
std::cout << "rCat is " << age << " years old!\n";
system("PAUSE");
return 0;
}
Here, you create the new object and return a reference to it to initialize the other object, which is legit, because every C++ class has a copy constructor by default. However, you'll get a memory leak here, because you create new object which is never deleted afterwards.
This can be a better version:
void TheFunction(SimpleCat*& rCat)
{
if (rCat!=NULL) delete rCat;
rCat = new SimpleCat(5,9);
// do something else with rCat if you want
return; //not required
}
int main()
{
SimpleCat * rCat = NULL;
TheFunction(rCat);
int age = rCat->GetAge();
std::cout << "rCat is " << age << " years old!\n";
system("PAUSE");
return 0;
}
Here, you initialize the new pointer by reference(which is also legit). When you declare the pointer, you declare the variable, which has an address, but doesn't have a sensible content yet. You give the reference to that address to your function, so you don't have to return anything. After the function has initialized your reference, you can use it from your main program. No memory will be leaked here, but only as long as all new pointers are initialized with NULL. So potentially this might cause problems too, if your pointer is somehow pointing to a garbage.
The third version (the safest) would be:
void TheFunction(SimpleCat& rCat)
{
rCat.age = 5;
rCat.weight = 9;
}
int main()
{
SimpleCat rCat;
TheFunction(rCat);
int age = rCat.GetAge();
std::cout << "rCat is " << age << " years old!\n";
system("PAUSE");
return 0;
}
There you give the reference to the new object to the function which will initialize it (i.e. assign some values to its members). The object already exists since the moment it's declared (only initialized by garbage by default), so this is also legit. No memory leak here either, because you don't claim memory for any new object.

Answer 2

SimpleCat * rCat;
SimpleCat & rCat = TheFunction(&rCat);
I don't think these lines are going to do what you think they do.
The first line is declaring a variable rCat that is a pointer to a cat, but never constructing a cat to go with it. The second is going to not work because you're declaring the same variable again. (can't have 2 rCat objects).
I'm still not quite sure what you're trying to do, though.
SimpleCat rCat;
TheFunction(&rCat);
and don't do:
rCat = new SimpleCat(...)
In TheFunction, just do the SetAge/SetWeight calls like you have them.
No leaks because you never called new. Of course, TheFunction no longer needs to return anything either because it's just modifying the object that was passed in. I'm not sure if that demonstrates what the author was trying to get to, though.
I think to demonstrate what the author wants, you'd change your TheFunction to be:
void TheFunction(SimpleCat& rCat) {
rCat.SetAge(5);
rCat.SetWeight(9);
}