Introduction to C++ Classes

Contents

• What are Classes
• Public and Private
• Implementing Class Functions
• Creating Instances(Objects) of a Class
• C++ Classes and C++ Structs
• Constructors
• Destructors
• The this Pointer

What are Classes

• The C++ class is a user-defined type.
• The class declaration is modeled after a structure declaration and can include data members and function members.
• A typical class declaration has the form:

        class className
        {
         private:
             // data member declarations
         public:
             // member function prototypes
        };

Public and Private

The Private Section

• It is not necessary to use the keyword private in class declarations, for that is the default access control for class objects:

        class Planet
        {
            float mass;        // private by default
            char name[20];     // private by default
         public:
            void rotation();
        };

• Because one of the main OOP precepts is to hide data, data items normally go into the private section.
• The private section protects the integrity of the data and is called data hiding
• You can put member functions in the private section. Typically, you use private member functions to handle implementation details that don't form part of the public interface.

The Public Section

• The contents of the public section constitute the abstract part of the design, the public interface.
• The member functions go into the public section; otherwise, you can't call those functions from a program.
• Member functions are also known as methods. Member functions are as much a part of your class as the member variables. They determine what the objects of your class can do.

Implementing Class Functions

• You can use a complete function definition instead of a function prototype in the class declaration, but the usual practice, except for very brief functions, is to provide the function definitions separately.
• In that case, you need to use the scope operator (::) to indicate to which class a member function belongs.
• A function definition within a class declaration is automatically an inline function. Since its declared within a class declaration, it does need the scope operator (::).
• Suppose the Planet class has a member function called getRulerName() that returns a pointer to a char. Then the function heading (declared outside the class declaration) would look like this:

       char * Planet::getRulerName()

  In other words, getRulerName() is not just a type char * function; it is a type char * function that belongs to the Planet class.
• The full, or qualified, name of the function is Planet::getRulerName().
• The name getRulerName(), on the other hand, is an abbreviation of the qualified name, and it can be used only in certain circumstances, such as in class method code.
• Another way of describing this situation is to say the name getRulerName() has class scope, so the scope resolution operator is needed to qualify the name when it is used outside the class declaration and a class method.

Creating Instances(Objects) of a Class

• To create an object, which is a particular instance, or example, of a class, use the class name as if it were a type name:

       Planet naboo;

• You use the dot membership operator to invoke a class member function (method) from a class object:

       cout << naboo.getRulerName();

C++ Classes and C++ Structs

• C++ extends to structures the same features classes have.
• The only difference is that the default access type for a structure is public, whereas the default type for the class is private.
• C++ programmers commonly use classes to implement class descriptions while restricting structures to representing pure data objects or, occasionally, classes with no private component.
• http://www.planetcpp.com/xtras/didyouknow.htm
• http://www.softcorp.demon.co.uk/c++2.htm

Constructors

What are Constructors

• A constructor is a special class member function that's called whenever an object of that class is created.
• A class constructor has the same name as its class.
• Through function overloading, you can have more than one constructor with the same name, provided that each has its own signature, or argument list.
• A class constructor has no declared type, not even void.
• Suppose the Planet class has the following prototype for a class constructor:

        Planet(char * pName, char * rName);	// constructor prototype

  Then you would use it to initialize new objects as follows:

        Planet naboo = Planet("Naboo", "Amidala");	// primary form
        Planet mars("Mars", "Martian");		// short form
        Planet *earth = new Planet("Earth", "Bush");	// dynamic object

Constructors with Only One Argument

• A constructor that you can use with a single argument allows you to use assignment syntax to initialise an object to a value. For instance, suppose you have this constructor prototype:

        Planet(double age);

  Then, you can use any of the following forms to initialize an object:

        Planet naboo = bozo(10000);	// primary form
        Planet mars(50000);		// short form
        Planet earth = 99999;		// special form for one-argument constructors

Default Constructors

• The default constructor is the constructor used to create an object when you don't provide explicit initialization values. It's the constructor used for declarations like this:

        Planet naboo;	// uses the default constructor

• Even if you fail to provide any constructors, C++ automatically supplies a default constructor. It's a default version of a default constructor, and it does nothing.
• However, if you define any constructor for a class, the responsibility for providing a default constructor for that class passes from the compiler to you. If you don't provide a default constructor, then the above declaration would not be possible.
• There are two ways to define a default constructor:
  1. provide default values for all the arguments to the existing constructor:

     Planet(char * pName = "Naboo", char * rulerName = "Amidala");

  2. use function overloading to define a second constructor, one that has no arguments:

     Planet()

Destructors

• When you use a constructor to create an object, the program undertakes the responsibility of tracking that object until it expires. At that time, the program automatically calls a special member function bearing the formidable title of destructor.
• The destructor cleans up any debris. For example, if your constructor uses new to allocate memory, the destructor should use delete to free that memory.
• The destructor has a special name: the class name preceded by a tilde(~). For example, the destructor of a class Planet would be:

        ~Planet();

• If your class doesn't provides a destructor, the compiler will automatically provide a destructor that does nothing.
• You can only have one destructor per class. It has no return type, not even void. It has no arguments either.

The this Pointer

• Each member function, including constructors and destructors, has a this pointer.
• The special property of the this pointer is that it points to the invoking object.
• If a method needs to refer to the invoking object as a whole, it can use *this.
• If you use the const qualifier after the function argument parentheses, you can't use this to change the object's value.

Quiz

Links