CS 160 - Programming Concepts and Applications

Focus on defining a Triangle class from scratch.

You should write a main.cpp function that shows each feature of your class working as expected (e.g., print out a triangle's area by calling the area function).

Consider a program that works with photographs. Photos have a height and a width. We might model such a class like this:

Since photos have a height and a width, they also have an area. What is a photo's area? It's a value generated by multiplying a Photo object's height and width together. How might we enable our Photo class such that a Photo object is able to tell us its area? In other words, what do we need to do in order to be able to write code like the following?

To support the ability to write p.area(), we must define area as a member function, or "a function that belongs to objects of a class." We do this in two steps.

In other words, in the header file Photo.h, we should add:

And in the implementation file, Photo.cpp, we should add:

The function prototype in Photo.h tells the machine, "Hey, Photo objects have a member function called area that returns an int." The function definition in Photo.cpp tells the machine, "Hey, the definition of the Photo member function area() I told you about in Photo.h works like this."

Look at the body of the area function above. Notice how the function, since it is declared "inside" the class, has direct access to everything else inside the class, such as height and width.

This is so important, we'd like you to read it again. Look at the body of the area function above. Notice how the function, since it is declared "inside" the class, has direct access to everything else inside the class, such as height and width.

When should you use member variables (e.g., height and width) instead of member functions in your main.cpp file? We hope you are starting to see why most seasoned programmers use member functions.

In Lab7A, you defined a simple Money class that used the public: syntax to tell the machine that the dollars and cents properties were "accessible from outside the object." For example, consider the following code:

Photo.h

Photo.cpp

That public: thing you see in the header file tells the machine, "Hey computer, when a programmer instantiates a Photo object, they should be allowed to access the values of height and width." In other words, this mechanism allows you to do the following:

Do you see how you can access the height attribute of the Photo myFamily, as well as assign a new value to this data member?

More importantly, do you see the problem? Look at this:

Uh oh! Because the height attribute is public, any programmer using Photo objects can assign any integer value to that member variable, including ones that don't make sense, such as negative heights.

"Big whoop," you say, "I know that we can make data members private." And you'd be right (and deserve a gold star for paying attention). Let's change our class so that arbitrary values can't be assigned to data members.

Photo.h

Ahh, there, now no one can assign values to Photo objects:

However, now you've introduced another problem. By declaring the data members to be private, you've disabled all access to the member variables! This means that you can no longer do this:

The height attribute is declared to be private, so there is no direct access to the attribute. Are you thinking, "I hate C++!"? Don't worry, here's how you can control access to data members: define member functions we call "getters and setters."

Let us restate the problem above: we do not want to allow direct access to member variables because invalid values can be assigned to them, causing the world to end (or, less dramatically, causing our program to be incorrect). We can declare a data member to be private, but then the programmer loses the ability to read the value of a data member as well.

The solution? Let us define two member functions that we use to manage reading and writing for each data member.

Photo.h

Photo.cpp

If you were to implement the code above, your programs could then do the following:

Spend time looking at the code in Photo.cpp above to see what those functions do. Notice how getHeight and getWidth are very similar. Almost every "getter" function you write will follow this pattern. Ditto for "setter" functions.

In order to understand how this works, you should realize that member functions have full access to everything declared inside the class; member functions are not subject to the public/private rules.

We've seen triangles before (i.e., A2). Now that you have some skills with classes, write a Triangle class to represent this "thing" to the computer. What properties do you need to represent a triangle? Make these properties private to your class. (You should know why private makes sense; ask if you don't!) In all functions that modify data members, you should always ensure the values being set make sense. Also, use a private helper function whenever one makes sense. Functions you should include in your class:

• A default constructor that sets all three sides of the triangle to one.
• Appropriate getter and setter functions.
• A boolean validate member function that tests whether a triangle is possible (e.g., if each side is smaller than the sum of the others).
• A function that returns a triangle's area. (See this link for an equation that you might want to use.)
• A function that returns a triangle's perimeter.

For added optional practice, consider using an array to represent the triangle's properties and create an array (or vector) of triangles in main. Be sure your main.cpp demonstrates all the functions of your class and that they work properly.