ch06.htm

good book for learning c++ standard language

<H3 ALIGN="CENTER"><A NAME="Heading34"></A><FONT COLOR="#000077">Inline Implementation</FONT></H3>
<P>Just as you can ask the compiler to make a regular function inline, you can make
class methods inline. The keyword <TT>inline</TT> appears before the return value.
The inline implementation of the <TT>GetWeight()</TT> function, for example, looks
like this:</P>
<PRE><FONT COLOR="#0066FF">inline int Cat::GetWeight()
{
return itsWeight;         // return the Weight data member
}
</FONT></PRE>
<P>You can also put the definition of a function into the declaration of the class,
which automatically makes that function inline. For example,</P>
<PRE><FONT COLOR="#0066FF">class Cat
{
public:
int GetWeight() { return itsWeight; }    // inline
void SetWeight(int aWeight);
};
</FONT></PRE>
<P>Note the syntax of the <TT>GetWeight()</TT> definition. The body of the inline
function begins im-mediately after the declaration of the class method; there is
no semicolon after the paren-theses. Like any function, the definition begins with
an opening brace and ends with a closing brace. As usual, whitespace doesn't matter;
you could have written the declaration as</P>
<PRE><FONT COLOR="#0066FF">class Cat
{
public:
int GetWeight()
{
return itsWeight;
}                           // inline
void SetWeight(int aWeight);
};
</FONT></PRE>
<P>Listings 6.6 and 6.7 re-create the <TT>Cat</TT> class, but they put the declaration
in <TT>CAT.HPP</TT> and the implementation of the functions in <TT>CAT.CPP</TT>.
Listing 6.7 also changes the accessor functions and the <TT>Meow()</TT> function
to inline.</P>

<P><A NAME="Heading35"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 6.6. Cat class
declaration in CAT.HPP</B></FONT><FONT COLOR="#0066FF"></FONT>
<PRE><FONT COLOR="#0066FF">1:  #include &lt;iostream.h&gt;
2:  class Cat
3:   {
4:  public:
5:   Cat (int initialAge);
6:   ~Cat();
7:    int GetAge() { return itsAge;}             // inline!
8:    void SetAge (int age) { itsAge = age;}     // inline!
9:    void Meow() { cout &lt;&lt; &quot;Meow.\n&quot;;}             // inline!
10:  private:
11: int itsAge;
<TT>12: };</TT></FONT>
</PRE>
<P><A NAME="Heading37"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 6.7. Cat implementation
in CAT.CPP</B></FONT><FONT SIZE="2" COLOR="#000077"><B>.</B></FONT><FONT COLOR="#0066FF"></FONT>
<PRE><FONT COLOR="#0066FF">1:   // Demonstrates inline functions
2:   // and inclusion of header files
3:
4:   #include &quot;cat.hpp&quot;  // be sure to include the header files!
5:
6:
7:   Cat::Cat(int initialAge)   //constructor
8:   {
9:      itsAge = initialAge;
10:  }
11:
12:  Cat::~Cat()             //destructor, takes no action
13:  {
14:  }
15:
16:  // Create a cat, set its age, have it
17:  // meow, tell us its age, then meow again.
18:  int main()
19:  {
20:     Cat Frisky(5);
21:     Frisky.Meow();
22:     cout &lt;&lt; &quot;Frisky is a cat who is &quot; ;
23:     cout &lt;&lt; Frisky.GetAge() &lt;&lt; &quot; years old.\n&quot;;
24:     Frisky.Meow();
25:     Frisky.SetAge(7);
26:     cout &lt;&lt; &quot;Now Frisky is &quot; ;
27:     cout &lt;&lt; Frisky.GetAge() &lt;&lt; &quot; years old.\n&quot;;
28:      return 0;
<TT>29: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: Meow.
Frisky is a cat who is 5 years old.
Meow.
Now Frisky is 7 years old.
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis: </B></FONT>The code presented in Listing 6.6
and Listing 6.7 is similar to the code in Listing 6.4, except that three of the methods
are written inline in the declaration file and the declaration has been separated
into <TT>CAT.HPP</TT>.<BR>
<TT>GetAge()</TT> is declared in line 7, and its inline implementation is provided.
Lines 8 and 9 provide more inline functions, but the functionality of these functions
is unchanged from the previous &quot;outline&quot; implementations.</P>
<P>Line 4 of Listing 6.7 shows <TT>#include &quot;cat.hpp&quot;</TT>, which brings
in the listings from <TT>CAT.HPP</TT>. By including <TT>cat.hpp</TT>, you have told
the precompiler to read <TT>cat.hpp</TT> into the file as if it had been typed there,
starting on line 5.</P>
<P>This technique allows you to put your declarations into a different file from
your implementation, yet have that declaration available when the compiler needs
it. This is a very common technique in C++ programming. Typically, class declarations
are in an <TT>.HPP</TT> file that is then <TT>#includ</TT>ed into the associated
CPP file.</P>
<P>Lines 18-29 repeat the main function from Listing 6.4. This shows that making
these functions inline doesn't change their performance.
<H3 ALIGN="CENTER"><A NAME="Heading38"></A><FONT COLOR="#000077">Classes with Other
Classes as Member Data</FONT></H3>
<P>It is not uncommon to build up a complex class by declaring simpler classes and
including them in the declaration of the more complicated class. For example, you
might declare a wheel class, a motor class, a transmission class, and so forth, and
then combine them into a car class. This declares a has-a relationship. A car has
a motor, it has wheels, and it has a transmission.</P>
<P>Consider a second example. A rectangle is composed of lines. A line is defined
by two points. A point is defined by an x-coordinate and a y-coordinate. Listing
6.8 shows a complete declaration of a <TT>Rectangle</TT> class, as might appear in
<TT>RECTANGLE.HPP</TT>. Because a rectangle is defined as four lines connecting four
points and each point refers to a coordinate on a graph, we first declare a <TT>Point</TT>
class, to hold the x,y coordinates of each point. Listing 6.9 shows a complete declaration
of both classes.</P>

<P><A NAME="Heading40"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 6.8. Declaring
a complete class.</B></FONT><FONT COLOR="#0066FF"></FONT>
<PRE><FONT COLOR="#0066FF">1:   // Begin Rect.hpp
2:   #include &lt;iostream.h&gt;
3:   class Point     // holds x,y coordinates
4:   {
5:      // no constructor, use default
6:      public:
7:         void SetX(int x) { itsX = x; }
8:         void SetY(int y) { itsY = y; }
9:         int GetX()const { return itsX;}
10:        int GetY()const { return itsY;}
11:     private:
12:        int itsX;
13:        int itsY;
14:  };    // end of Point class declaration
15:
16:
17:  class  Rectangle
18:  {
19:     public:
20:        Rectangle (int top, int left, int bottom, int right);
21:        ~Rectangle () {}
22:
23:        int GetTop() const { return itsTop; }
24:        int GetLeft() const { return itsLeft; }
25:        int GetBottom() const { return itsBottom; }
26:        int GetRight() const { return itsRight; }
27:
28:        Point  GetUpperLeft() const { return itsUpperLeft; }
29:        Point  GetLowerLeft() const { return itsLowerLeft; }
30:        Point  GetUpperRight() const { return itsUpperRight; }
31:        Point  GetLowerRight() const { return itsLowerRight; }
32:
33:        void SetUpperLeft(Point Location)  {itsUpperLeft = Location;}
34:        void SetLowerLeft(Point Location)  {itsLowerLeft = Location;}
35:        void SetUpperRight(Point Location)  {itsUpperRight = Location;}
36:        void SetLowerRight(Point Location)  {itsLowerRight = Location;}
37:
38:        void SetTop(int top) { itsTop = top; }
39:        void SetLeft (int left) { itsLeft = left; }
40:        void SetBottom (int bottom) { itsBottom = bottom; }
41:        void SetRight (int right) { itsRight = right; }
42:
43:        int GetArea() const;
44:
45:     private:
46:        Point  itsUpperLeft;
47:        Point  itsUpperRight;
48:        Point  itsLowerLeft;
49:        Point  itsLowerRight;
50:        int    itsTop;
51:        int    itsLeft;
52:        int    itsBottom;
53:        int    itsRight;
54:  };
<TT>55: // end Rect.hpp</TT></FONT></PRE>
<P><A NAME="Heading42"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 6.9. RECT.CPP.</B></FONT></P>
<PRE><FONT COLOR="#0066FF">1:   // Begin rect.cpp
2:   #include &quot;rect.hpp&quot;
3:   Rectangle::Rectangle(int top, int left, int bottom, int right)
4:   {
5:         itsTop = top;
6:         itsLeft = left;
7:         itsBottom = bottom;
8:         itsRight = right;
9:
10:        itsUpperLeft.SetX(left);
11:        itsUpperLeft.SetY(top);
12:
13:        itsUpperRight.SetX(right);
14:        itsUpperRight.SetY(top);
15:
16:        itsLowerLeft.SetX(left);
17:        itsLowerLeft.SetY(bottom);
18:
19:        itsLowerRight.SetX(right);
20:        itsLowerRight.SetY(bottom);
21:  }
22:
23:
24:  // compute area of the rectangle by finding corners,
25:  // establish width and height and then multiply
26:  int Rectangle::GetArea() const
27:  {
28:        int Width = itsRight-itsLeft;
29:        int Height = itsTop - itsBottom;
30:        return (Width * Height);
31:  }
32:
33:  int main()
34:  {
35:        //initialize a local Rectangle variable
36:        Rectangle MyRectangle (100, 20, 50, 80 );
37:
38:        int Area = MyRectangle.GetArea();
39:
40:        cout &lt;&lt; &quot;Area: &quot; &lt;&lt; Area &lt;&lt; &quot;\n&quot;;
41:        cout &lt;&lt; &quot;Upper Left X Coordinate: &quot;;
42:        cout &lt;&lt; MyRectangle.GetUpperLeft().GetX();
43:      return 0;
<TT>44: }</TT>
Output: Area: 3000
Upper Left X Coordinate: 20
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis: </B></FONT>Lines 3-14 in Listing 6.8 declare
the class <TT>Point</TT>, which is used to hold a specific x,y coordinate on a graph.
As written, this program doesn't use <TT>Point</TT>s much. However, other drawing
methods require <TT>Point</TT>s.<BR>
Within the declaration of the class <TT>Point</TT>, you declare two member variables
(<TT>itsX</TT> and <TT>itsY</TT>) on lines 12 and 13. These variables hold the values
of the coordinates. As the x-coordinate increases, you move to the right on the graph.
As the y-coordinate increases, you move upward on the graph. Other graphs use different
systems. Some windowing programs, for example, increase the y-coordinate as you move
down in the window.</P>
<P>The <TT>Point</TT> class uses inline accessor functions to get and set the <TT>X</TT>
and <TT>Y</TT> points declared on lines 7-10. <TT>Point</TT>s use the default constructor
and destructor. Therefore, you must set their coordinates explicitly.</P>
<P>Line 17 begins the declaration of a <TT>Rectangle</TT> class. A <TT>Rectangle</TT>
consists of four points that represent the corners of the <TT>Rectangle</TT>.</P>
<P>The constructor for the <TT>Rectangle</TT> (line 20) takes four integers, known
as <TT>top</TT>,<TT> left</TT>,<TT> bottom</TT>, and <TT>right</TT>. The four parameters
to the constructor are copied into four member variables (Listing 6.9) and then the
four <TT>Points</TT> are established.</P>
<P>In addition to the usual accessor functions, <TT>Rectangle</TT> has a function
<TT>GetArea()</TT> declared in line 43. Instead of storing the area as a variable,
the <TT>GetArea()</TT> function computes the area on lines 28-29 of Listing 6.9.
To do this, it computes the width and the height of the rectangle, and then it multiplies
these two values.</P>
<P>Getting the x-coordinate of the upper-left corner of the rectangle requires that
you access the <TT>UpperLeft</TT> point, and ask that point for its <TT>X</TT> value.
Because <TT>GetUpperLeft()</TT>is <TT>()</TT>a method of <TT>Rectangle</TT>, it can
directly access the private data of <TT>Rectangle</TT>, including <TT>itsUpperLeft</TT>.
Because <TT>itsUpperLeft</TT> is a <TT>Point</TT> and <TT>Point</TT>'s <TT>itsX</TT>
value is private, <TT>GetUpperLeft()</TT> cannot directly access this data. Rather,
it must use the public accessor function <TT>GetX()</TT> to obtain that value.</P>
<P>Line 33 of Listing 6.9 is the beginning of the body of the actual program. Until
line 36, no memory has been allocated, and nothing has really happened. The only
thing you've done is tell the compiler how to make a point and how to make a rectangle,
in case one is ever needed.</P>
<P>In line 36, you define a <TT>Rectangle</TT> by passing in values for <TT>Top</TT>,
<TT>Left</TT>, <TT>Bottom</TT>, and <TT>Right</TT>.</P>
<P>In line 38, you make a local variab