3.7 CREATING PRINT REPRESENTATIONS FOR OBJECTS

As a result, we can now directly supply a User argument to the System.out.println method in class Test, as we show in line (B).

We could use the same strategy in a C++ program; that is, equip a class with a toString() -like function that creates a string representation from the values of the data members of the class. The string thus constructed could then be output by, say, the usual output operator ‘<<’. However, a more common way to create print representations in C++ is to overload the output operator directly for a class, as we do in the example below in line (C). The syntax used will make sense after we have discussed the friend declaration in Section 3.11 of this chapter and operator overloading in Chapter 12. From the syntax shown in line (D), note how the operator overload definition of line (C) allows us to use a User object directly as an operand for the output operator.

//PrintObj.cc #include <

iostream

> #include <string> using namespace std; class User { string name; int age; public: User( string str, int yy ) { name = str; age = yy; } friend ostream& operator<<(

ostream

& os, const User& user) { //(C) os << "Name: " << user.name << " Age: " << user.age << endl; } }; int main() { User us( "Zaphod", 119 ); cout << us << endl; // Name: Zaphod Age: 119 //(D) return 0; }

3.8 OBJECT DESTRUCTION

When objects go out of scope ^[7] in C++, they are automatically destroyed by the invocation of their destructors. A destructor is given the name of the class prefixed with a tilde. It should not return a value, neither should it take a parameter, as in the following example where we have supplied class Y with a destructor of its own in line (C). If a class has not been supplied explicitly with a destructor, the default meaning of the destructor is invoked for objects made from that class. The default meaning is to invoke the destructors for each of the data members of the class. For data members of the primitive types, destruction simply means freeing up the memory occupied by them.

//Dest.cc

#include <

iostream

>
using namespace std;

class X {};

class Y {
     X* p;                                      //(A)
public:
     Y( X* q ) : p( new X(*q) ){}               //(B)
     ~Y(){ delete p; }                          //(C)
};

int main() {
     X* px = new X();                           //(D)
     Y y( px );                                 //(E)
     delete px;                                 //(F)
     return 0;
}

As the variable y in line (D) goes out of scope when the flow of execution hits the right brace of main, Y 's destructor in line (C) will be invoked automatically.

As will be explained in greater detail in Chapter 11, programmer-supplied destructors are needed particularly when an object appropriates system resources that need to be freed up before the object is destroyed. In our example here, construction of an object of type Y in line (B) entails allocating memory for an object of type X to which the data member p points. The system supplies a class with a default destructor if the programmer does not provide one. If we had not supplied Y with a destructor as shown in line (C), its default destructor would have just freed up the four bytes occupied by the pointer data member p, but not the memory to which p points. ^[8]

Java's object destruction works very differently from C++. If no variables in a Java program are holding references to an object, that object becomes a candidate for what is known as garbage collection . The garbage collector runs continuously in the background in a separate but low-priority thread. To somewhat compensate for the fact that it is beyond the control of a programmer to reclaim the memory occupied by an object at the very instant it becomes unreferenced, Java gives the programmer the option of asking the garbage collector to make a best effort to right away reclaim the space occupied by all unreferenced objects by invoking

System.gc();

Before actually destroying an object, the garbage collector executes the code in the finalize() method of the object assuming the class was given such a method. The finalize() method does for Java what a programmer-supplied destructor does for C++-it can be used to close I/O connections, files, and so on. Chapter 11 goes more deeply into Java's garbage collection and object finalization .