Thread: Passing objects?!

Few questions about how to pass objects around a C++ program.

Using "pointers" or "references" is the most efficient way.

You need to learn about "pointers", which don't have a counterpart in Java, and you need to learn about "references", which are much different in C++. You also need to learn about the differences between "passing by value" and "passing by reference". Passing by value does not exist in Java, and passing by reference has a different syntax and some different repercussions than in Java.

Here is an example:

Code:

#include <iostream>
#include <string>
using namespace std;

class Cat
{
private:
	string name;

public:
	Cat(string n)
	{
		name = n;
	}
	
	Cat()
	{
		name="";
	}

	void display()
	{
		cout<<"I'm a cat, and my name is "<<name<<endl;
	}
};

class Apple 
{
private:
	Cat myCat;

public:
	Apple(const Cat& aCat) 
	{
		myCat = aCat;
	}

	void show()
	{
		cout<<"I'm an apple."<<endl;
		myCat.display();
	}
};


int main()
{
	Cat myCat("Whiskers");
	myCat.display();

	cout<<endl<<"Apple:"<<endl;
	Apple a(myCat);
	a.show();

	return 0;
}

There are a couple of things going on in the Apple constructor that aren't apparent. First, when the Apple constructor is called, the Apple object is created before any code in the constructor body is executed. But, in order to create the Apple object, the compiler has to create the myCat object. It does that by calling the default Cat constructor--if there's no default Cat constructor, you will get an error. That is why I had to define a default constructor for the Cat class.

After the Apple object is constructed, then the body of the constructor is executed. In the body of the constructor, the member variable myCat is assigned the object aCat. In order to do that assignment, the compiler calls something called the "copy constructor". The compiler automatically supplies a default copy constructor for a class. Unlike Java which supplies classes with only a default constructor, C++ supplies classes with various other default functions. In any case, the default copy constructor just copies each member of aCat into myCat. That can have dire consequences in some circumstances, but not in this case. In Java, if you did a similar assignment, then myCat and aCat would both refer to the same object. However, in C++, after the copy constructor copies each member of aCat into myCat, myCat and aCat are two different objects.

In C++, you are going to see a lot of "const" specifiers in front of function parameter names, e.g.:

Apple(const Cat& aCat)

The const specifier announces that the function is not allowed to change the parameter in any way. So, if you have a function, and the function doesn't need to change the argument passed to it, put const in front of the parameter name. If you make a mistake inside the function and try to change a const argument, the compiler will give you an error--alerting you that you are doing something you said you didn't want to do.

If the "const" specifiers in front of a function's parameter names confuse you, just cross them out--they don't affect the type of the variable you send to the function, they only affect whether the function is allowed to change their values inside the function.