Thread: Constructors

//Listing 9.10
// Passing pointers to objects

#include <iostream>

using namespace std;
class SimpleCat
{
public:
SimpleCat (); // constructor
SimpleCat(SimpleCat&); /* what does this symbol & to the right of a parameter mean like here in SimpleCat&?*/
~SimpleCat(); // destructor
};

SimpleCat::SimpleCat()
{
cout << "Simple Cat Constructor...\n";
}

SimpleCat::SimpleCat(SimpleCat&)
{
cout << "Simple Cat Copy Constructor...\n";
}

SimpleCat::~SimpleCat()
{
cout << "Simple Cat Destructor...\n";
}

SimpleCat FunctionOne (SimpleCat theCat);
SimpleCat* FunctionTwo (SimpleCat *theCat);

int main()
{
cout << "Making a cat...\n";
SimpleCat Frisky;
cout << "Calling FunctionOne...\n";
FunctionOne(Frisky);
cout << "Calling FunctionTwo...\n";
FunctionTwo(&Frisky);
return 0;
}

// FunctionOne, passes by value
SimpleCat FunctionOne(SimpleCat theCat)
{
cout << "Function One. Returning...\n";
return theCat;
}

// functionTwo, passes by reference
SimpleCat* FunctionTwo (SimpleCat *theCat)
{
cout << "Function Two. Returning...\n";
return theCat;
}

>>SimpleCat(SimpleCat&);

Means that SimpleCat can recieve a reference to another SimpleCat in its constructor.....

The '&' means it is passed by reference and not copy, so when the function call is made to that constructor, the overhead of copying an entire copy of a SimpleCat is avoided. On the downside, the value passed can be altered by that function which can lead to problems. Often the keyword 'const' would be used in the declaration to avoid this.

ok, now I am confused between this &SimpleCat and this SimpleCat&...please elaborate more.

I'll try.....

SimpleCat&

This is used here as part of a function declaration. It means that the function expects to recieve an object of type "SimpleCat" passed by reference.

SimpleCat(SimpleCat&);

could be written as

SimpleCat(SimpleCat& myCat);
or
SimpleCat(SimpleCat &myCat);

The fact that you dont explictly need to give a name to the object/variable recived in the constructor declaration often makes it confusing.


&SimpleCat

You can get the memory address of the variable by putting '&' on the left of a variable.
Often, you wouldnt use this like that because you would be trying to access the address of a class type......when you would more commonly want the address of the object that you had created an instance of. For example

SimpleCat myCat; //an instance of a SimpleCat
SimpleCat *ptrCat; //a pointer to an object of type 'SimpleCat'

ptrCat = &myCat; //set the memory address of the pointer ptrCat to that of myCat

Hope this helps

This is used here as part of a function declaration. It means that the function expects to recieve an object of type "SimpleCat" passed by reference.

Which Function? do you mean FunctionOne(Frisky)? and if so, how is in FunctionOne(Frisky)...how is Frisky here passed by referenced?( What tells me that Frisky is function one is boing to be passed by reference) Because copy constructor is only called when FunctionOne(Frisky) is called.



PS please help..................... this book is starting to confuse me.

Ok thanks for all your help but the main problem here is that this books gets ahead of itself at times...I DID NOT KNOW THAT EVERYTIME YOU PASS AN OBJECT VALUE TO A FUNCTION OR AS A FUNCTION RETURN VALUE a copy constructor is called automatically..........after looking at the index for copy constructor and finding the page number and looking at the topic I think I understand why SimpleCat(SimpleCat&) is the copy constructor and why it is called. Although I find this book to be pretty good and detailed at explaining things I am afraid that it gets ahead of itself at time.................