Lesson 12: Introduction to Classes

C++ is a bunch of small additions to C, and one major addition. This one addition is the object-oriented approach. As its name suggests, this deals with objects. Of course, these are not real-life objects. Instead, these objects are the essential definitions of real world objects. Structures are one step away from these objects, they do not possess one element of them: functions. The definitions of these objects are called classes. The easiest way to think about a class is to imagine a structure that has functions.

What is this mysterious structure (not the programming type)? Well, it is not only a collection of variables under one heading, but it is a collection of functions under that same heading. If the structure is a house, then the functions will be the doors and the variables will be the items inside the house. They usually will be the only way to modify the variables in this structure, and they are usually the only to access the variables in this structure.

From now on, we shall call these structures with functions classes (I guess Marx would not like C++). The syntax for these classes is simple. First, you put the keyword 'class' then the name of the class. Our example will use the name computer. Then you put an open bracket. Before putting down the different variables, it is necessary to put the degree of restriction on the variable. There are three levels of restriction. The first is public, the second protected, and the third private. For now, all you need to know is that the public restriction allows any part of the program, including that which is not part of the class, access the variables specified as public. The protected restriction prevents functions outside the class to access the variable. The syntax for that is merely the restriction keyword (public, private, protected) and then a colon. Finally, you put the different variables and functions (You usually will only put the function prototype[s]) you want to be part of the class. Then you put a closing bracket and semicolon. Keep in mind that you still must end the function prototype(s) with a semi-colon.

Classes should always contain two functions: the constructor and destructor. The syntax for them is simple, the class name denotes a constructor, a ~ before the class name is a destructor. The basic idea is to have the constructor initialize variables, and to have the destructor clean up after the class, which includes freeing any memory allocated. The only time the constructor is called is when the programmer declares an instance of the class, which will automatically call the constructor. The only time the destructor is called is when the instance of the class is no longer needed. When the program ends, or when its memory is deallocated (if you do not understand the deallocation part, do not worry). Keeps in mind this: NEITHER constructors NOR destructors RETURN AN ARGUMENT! This means you do not want to try to return a value in them.

The syntax for defining a function that is a member of a class outside of the actual class definition is to put the return type, then put the class name, two colons, and then the function name. This tells the compiler that the function is a member of that class.

For example:

void Aclass::aFunction()
{
  cout<<"Whatever code";
}


#include <iostream.h>

class Computer //Standard way of defining the class
{
 
 public:
    //This means that all of the functions below this
    //(and variables, if there were any)
     //are accessible to the rest of the program.
     //NOTE: That is a colon, NOT a semicolon...
 
Computer();
    //Constructor
 ~Computer();
    //Destructor
 void setspeed(int p);
 int readspeed(); 
    //These functions will be defined outside of the class
protected:
   //This means that all the variables under this, 
   //until a new type of restriction is placed, 
   //will only be accessible to other functions in the
   //class. NOTE: That is a colon, NOT a semicolon...
int processorspeed;
 

};
   //Do Not forget the trailing semi-colon


Computer::Computer()
{    //Constructors can accept arguments, but this one does not
  processorspeed = 0;
       //Initializes it to zero
}

Computer::~Computer()
{      //Destructors do not accept arguments
}

//The destructor does not need to do anything.

void Computer::setspeed(int p)
{    //To define a function outside put the name of the function
    //after the return type and then two colons, and then the name
    //of the function. 

  processorspeed = p;
}
int Computer::readspeed()
{      //The two colons simply tell the compiler that the function is part
       //of the class
  return processorspeed;
}

int main()
{
  Computer compute;
    //To create an 'instance' of the class, simply treat it like you would        
    //a structure.  (An instance is simply when you create an actual object
    //from the class, as opposed to having the definition of the class)
  compute.setspeed(100);
    //To call functions in the class, you put the name of the instance,
    //a period, and then the function name.
  cout<<compute.readspeed();
    //See above note.
  return 0;
}

As you can see, this is a rather simple concept. However, it is very powerful. It makes it easy to prevent variables that are contained (or owned) by the class being overwritten accidentally. It also allows a totally different way of thinking about programming. I want to end this tutorial as an introduction, however.