Table of Contents

Beginning Classes (and C++)

So far this semester we have been exclusively using the C Programming Language. C++ is in many ways an evolved C, taking and adding to its capabilities (and in some ways enabling some bad programming habits).

C++'s claim to fame is that it is “Object-Oriented”, which is based on this notion of classes, objects, and code management in general.

To know C is to know like 90% of C++. C++ merely adds a few things. If you do not know C, that means one must effectively learn two languages to get up and running in C++.

So, once again: EVERYTHING you have learned in C is pretty much valid C++ code.

For example, if we made a file called hello.cc (note the extension– the C++ compiler prefers we name our files with a .cc, .cpp, .c++, or .C extension to distinguish it from C's .c), we can pull of what should be a very familiar looking program:

#include <stdio.h>
 
int main()
{
    printf("Hello, World!\n");
    return(0);
}

That IS C code. It can be dropped wholesale into a C++ file and compiled with a C++ compiler (g++ in our case).

Classes (Implementation)

The centerpiece of C++ is its ability to use classes.

What you need to know about classes is that they are essentially structs with added capabilities. If you understand structs, you understand the foundation of classes.

Following is the declaration of a Rectangle Class (notice how similar it is to declaring a struct). It might not be a bad idea to put this in a file called rectangle.h:

class Rectangle {
    public:
        Rectangle();         // Constructor (parameterless)
        Rectangle(int, int); // Overloaded  (parametered)
        void setWidth(int);  // Accessor Method
        void setHeight(int); // Accessor Method
        int  getWidth();     // Accessor Method
        int  getHeight();    // Accessor Method
        int  area();         // Calculate the area of the Rectangle
        int  perimeter();    // Calculate the perimeter of the Rectangle
 
    private:
        int width;
        int height;
};

Now, a difference between a class and a struct is that classes can have function prototypes (structs do not allow this, although they CAN have function pointers).

We see the use of some labels- “Public:” and “Private:” (there is a third- “Protected:”, these three denote class access control). Labels themselves are not unique to C++; we can use them in C. But in C++, these three labels hold special meaning.

Basically:

Using these levels of access control, we can better manage our data and code by dictating how others can utilize our code. Again, this is really more of an organizational thing. Let me say it again, C++ is more about managing your C code. If you don't understand the C part, how can you be expected to successfully manage it?

Now for the class implementation. Some new syntax is used; put this in a file called rectangle.cc:

Rectangle :: Rectangle()
{
    width  = 0;
    height = 0;
}
 
Rectangle :: Rectangle(int width, int height)
{
    this.width  = width;
    this.height = height;
}
 
void Rectangle :: setWidth(int width)
{
    this.width  = width;
}
 
void Rectangle :: setHeight(int height)
{
    // Left as an exercise to the implementer
}
 
int Rectangle :: getWidth()
{
    // Left as an exercise to the implementer
}
 
int Rectangle :: getHeight()
{
    return(height);
}
 
int Rectangle :: area()
{
    // Left as an exercise to the implementer
}
 
int Rectangle :: perimeter()
{
    // Left as an exercise to the implementer
}

Immediately, five new things have been used in this code.

Using classes

Now that we have a class, let's actually use it. Please note that Object-Oriented Programming has further solidified a certain role in the development process– with C we had library implementers, application implementers, and users. In C++, those same relationships exist, only they tend to become more pronounced (you aren't always implementing all the classes you use).

The following code will utilize our Rectangle class through instantiating a few objects (an object is a class in action). Put this in a file called main.cc. Not how similar it looks to C code:

#include <stdio.h>
#include "rectangle.h"
 
int main()
{
    Rectangle r1, r2, *r3;
 
    r3 = new Rectangle(14, 15);
 
    r1.setWidth(24);
    r1.setHeight(16);
 
    //r2.height = 17;
    //r2.width  = 13;
 
    printf("r1 has a width of %d and a height of %d.\n", r1.getWidth(), r1.getHeight);
    printf("r1's perimeter is %d and area is %d.\n", r1.perimeter(), r1.area);
 
    //printf("r1 has a width of %d and a height of %d.\n", r1.getWidth(), r1.getHeight);
    //printf("r1's perimeter is %d and area is %d.\n", r1.perimeter(), r1.area);
 
    // Do the same- display these values for r3
 
    return(0);
}

Compilation

To compile this code, we treat it as a multi-file program (no different than with C). Remember to use g++, it is the C++ compiler:

$ g++ -c rectangle.cc
$ g++ -c main.cc
$ g++ -o myprog main.o rectangle.o