Managing Complexity

As you all can well imagine by now, things can get pretty hairy and complicated when trying to program. What we need to fix this are ways to keep programs from getting too complex to write and understand. We have seen that we can use functions for control, but what do we do about the data? What can we do to keep our data in an orderly fashion? Let's try objects.

Objects

Objects can be described as:

• A way to package together data and operations on that data.
• Objects are easy to program but look a little weird at first.
• Once in place they make modifications a much easier process.
• And they are easy to use in other programs.

Example: circles

So far we have been using circles in the context of QuickDraw and now we are going to use them to help us understand how objects work.

  //Draw a circle centered at (300,200) with radius 75.
  Rect r;
  SetRect(&r, 300 - 75, 200 - 75, 300 + 75, 200 + 75);
  PaintOval(&r);

Now how would we manipulate ths circle??

• Move it by calling OffsetRect().
• Changing the center would be equivalent to a move.
• Change the radius by calling SetRect() or InsetRect().
• But how do we calculate the area?
• And what about the color?

As can be seen things are not as clear cut as they should be. To use this circle you have to know that it is stored as a Rect. But think about this: Do you have to know how many valves per cylinder your car has in order to drive it? The obvious answer is no, so why should you have to know how a circle is stored?

Object Ideas

One thing we can do is encapsulate together all the data needed to describe an object and all the functions that will operate on it. Another good idea would be to abstract the object's interactions with the outside world so that you need to know as little as possible about how the object is really implemented in order to use it.

For our circle:

• center
• radius
• color

• set center
• set radius
• draw
• compute area
• others?? move, scale, ...

Only these functions should access the data unless we give explicit permission to other functions.

Things to note about circles1.cpp

• The class definition syntax, and it ending in a semicolon.
• The objects have a private and public section. The default for classes is private, but you should use the keyword private so that there is no doubt.
• Contained in the class are member functions and data. By convention we usually make the functions public and the data private, but there are some exceptions.
• Notice the declaration of the circle object in main().
• The syntax of call of the member function:
  • objectName.memberFunc(params);
  • The object name determines which class we use the function from.
• The syntax of a member function definition:

      returnType  className::memberFunc(params)
      {
        ...
      }

• The use of the private member data in the member functions. This is OK because they are allowed access. But how do we know which circle's center, radius, or color? We know this by the one specified in the call, such as c1 in the call
  • c1.draw();

It is easy to change or add member functions.

A Counter Object

A counter has data:

• Current value.
• Limit (Value wraps to 0 when it reaches limit).

A counter also has functions:

• Initialize.
• Show the value.
• Tick, i.e., increment value while wrapping as needed.

See Demo counter1.cpp