Introduction to Classes in C++
C++ is a bunch of small additions to C, with a few major additions. One major
addition is the object-oriented approach (the other addition is support for generic
programming, which we'll cover later). As the name object-oriented
programming suggests, this approach deals with objects. Of course, these are
not real-life objects themselves. Instead, these objects are the essential
definitions of real world objects. Classes are collections of data related to
a single object type. Classes not only include information regarding the real
world object, but also functions to access the data, and classes possess the
ability to inherit from other classes. (Inheritance is covered in a later
lesson.)
If a class is a house, then the functions will be the doors and the
variables will be the items inside the house. The functions usually will be the only
way to modify the variables in this structure, and they are usually the only
way even to access the variables in this structure. This might seem silly at
first, but the idea to make programs more modular - the principle itself is
called "encapsulation". The key idea is that the outside world doesn't need
to know exactly what data is stored inside the class--it just needs to know
which functions it can use to access that data. This allows the
implementation to change more easily because nobody should have to rely on it
except the class itself.
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 parts outside the class, to access the
functions and variables specified as public. The protected restriction
prevents functions outside the class to access the variable. The private
restriction is similar to protected (we'll see the difference later when we
look at inheritance. The
syntax for declaring these access restrictions 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.
Let's look at these different access restrictions for a moment. Why would you
want to declare something private instead of public? The idea is that some
parts of the class are intended to be internal to the class--only for the
purpose of implementing features. On the other hand, some parts of the class
are supposed to be available to anyone using the class--these are the public
class functions. Think of a class as though it were an appliance like a
microwave: the public parts of the class correspond to the parts of the
microwave that you can use on an everyday basis--the keypad, the start button,
and so forth. On the other hand, some parts of the microwave are not easily
accessible, but they are no less important--it would be hard to get at the
microwave generator. These would correspond to the protected or private parts
of the class--the things that are necessary for the class to function, but
that nobody who uses the class should need to know about. The great thing
about this separation is that it makes the class easier to use
(who would want to use a microwave where you had to know exactly how it works
in order to use it?) The key idea is to separate the interface you use from
the way the interface is supported and implemented.
Classes must always contain two functions: a constructor and a 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. If it turns out that
you don't need to actually perform any initialization, then you can allow the
compiler to create a "default constructor" for you. Similarly, if you don't
need to do anything special in the destructor, the compiler can write it for
you too!
When the programmer declares an instance of the class, the constructor will be
automatically called. The only time the destructor is called is when the
instance of the class is no longer needed--either when the program ends, the
class reaches the end of scope, or when its memory is deallocated using delete
(if you don't understand all of that, don't worry; the key idea is that
destructors are always called when the class is no longer usable). Keep in
mind that neither constructors nor destructors return arguments! This means
you do not want to (and cannot) return a value in them.
Note that you generally want your constructor and destructor to be
made public so that your class can be created! The constructor is called when
an object is created, but if the constructor is private, it cannot be
called so the object cannot be constructed. This will cause the compiler to
complain.
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:
#include <iostream>
using namespace std;
class Computer // Standard way of defining the class
{
public:
// This means that all of the functions below this(and any variables)
// 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();
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;
}
Computer::~Computer()
{
//Destructors do not accept arguments
}
void Computer::setspeed ( int p )
{
// To define a function outside put the name of the class
// 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.
}
|