How nice it would be if we could create objects in C++ that have the relevant properties of the real-world objects we're trying to model. What we need is a structure that can hold all the different types of data necessary to describe a single object. C++ calls the structure that combines multiples pieces of data into a single object a class.

A class consists of the keyword class followed by a name and an open and closed brace. A class used to describe a savings account including account number and balance might appear as follows:

class SavingsAccount
{
  public:
    unsigned accountNumber;
    double balance;
};

The statement after the open brace is the keyword public. (Hold off asking about the meaning of the public keyword. I'll make its meaning public a little later.)

Following the public keyword are the entries it takes to describe the object. The SavingsAccount class contains two elements: an unsigned integer accountNumber and the account balance. We can also say that accountNumber and balance are members or properties of the class SavingsAccount.

To create an actual savings account object, I type something like the following:

SavingsAccount mySavingsAccount;

We say that mySavingsAccount is an instance of the class SavngsAccount.

The following syntax is used to access the property of a particular object:

// Create a savings account object
SavingsAccount mySave;
mySave.accountNumber = 1234;
mySave.balance = 0;

// Input a second savings account from the keyboard
cout << "Input your account number and balance" << endl;
SavingsAccount urSave;
cin >> urSave.accountNumber;
cin >> urSave.balance;

This code snippet declares two objects of class SavingsAccount, mySave and urSave. The snippet initializes mySave by assigning a value to the account number and a 0 to the balance (as per usual for my savings account). It then creates a second object of the same class, urSave. The snippet reads the account number and balance from the keyboard.

An important point to note in this snippet is that mySave and urSave are separate, independent objects. Manipulating the members of one has no effect on the members of the other (lucky for urSave).

In addition, the name of the member without an associated object makes no sense. I cannot say either of the following:

balance = 0;                 // illegal; no object
SavingsAccount.balance = 0;  // class but still no object

Every savings account has its own unique account number and maintains a separate balance. (There may be properties that are shared by all savings accounts — we'll get to those soon enough — but account and balance don't happen to be among them.)

You use classes to simulate real-world objects. The Savings class tries to represent a savings account. This allows you to think in terms of objects rather than simply lines of code. The closer C++ objects are to modeling the real world, the easier it is to deal with them in programs. This sounds simple enough. However, the Savings class doesn't do a very good job of simulating a savings account.

class Savings
{
  public:
    double deposit(double amount)
    {
        balance += amount;
        return balance;
    }

    unsigned accountNumber;
    double balance;
};

class Savings
{
  public:
    unsigned accountNumber;

double balance;
};
double deposit(Savings& s, double amount)
{
    s.balance += amount;
    return s.balance;
}

To demonstrate member functions, start by defining a class Student. One possible representation of such a class follows (taken from the program CallMemberFunction):

class Student
{
  public:
    // add a completed course to the record
    float addCourse(int hours, float grade)
    {
        // calculate the sum of all courses times
        // the average grade
        float weightedGPA;
        weightedGPA = semesterHours * gpa;

        // now add in the new course
        semesterHours += hours;
        weightedGPA += grade * hours;
        gpa = weightedGPA / semesterHours;

// return the new gpa
        return gpa;
    }

    int  semesterHours;
    float gpa;
};

The function addCourse(int, float) is called a member function of the class Student. In principle, it's a property of the class like the data members semesterHours and gpa.

Sometimes functions that are not members of a class are class "plain ol' functions," but I'll refer to them simply as nonmembers.

The following CallMemberFunction program shows how to invoke the member function addCourse():

//
//  CallMemberFunction - define and invoke a function
//               that's a member of the class Student
//
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;

class Student
{
  public:
    // add a completed course to the record
    float addCourse(int hours, float grade)
    {

// calculate the sum of all courses times
        // the average grade
        float weightedGPA;
        weightedGPA = semesterHours * gpa;

        // now add in the new course
        semesterHours += hours;
        weightedGPA += grade * hours;
        gpa = weightedGPA / semesterHours;

        // return the new gpa
        return gpa;
    }

    int  semesterHours;
    float gpa;
};

int main(int nNumberofArgs, char* pszArgs[])
{
     // create a Student object and initialize it
     Student s;
     s.semesterHours = 3;
     s.gpa = 3.0;

     // the values before the call
     cout << "Before: s = (" << s.semesterHours
          << ", "     << s. gpa
          << ")" << endl;

    // the following subjects the data members of the s
    // object to the member function addCourse()
    cout << "Adding 3 hours with a grade of 4.0" << endl;
    s.addCourse(3, 4.0); // call the member function

    // the values are now changed
    cout << "After: s = (" << s.semesterHours
         << ", "     << s. gpa
         << ")"      << endl;

    // wait until user is ready before terminating program
    // to allow the user to see the program results
    system("PAUSE");
    return 0;
}

The syntax for calling a member function looks like a cross between the syntax for accessing a data member and that used for calling a function. The right side of the dot looks like a conventional function call, but an object is on the left of the dot.

In the call s.addCourse(), we say that "addCourse() operates on the object s" or, said another way, "s is the student to which the course is to be added." You can't fetch the number of semester hours without knowing from which student to fetch those hours — you can't add a student to a course without knowing which student to add. Calling a member function without an object makes no more sense than referencing a data member without an object.

int main(int nNumberofArgs, char* pszArgs[])
{
    Student s;
    s.semesterHours = 10;
    s.gpa      = 3.0;
    s.addCourse(3, 4.0); // call the member function

    Student t;
    t.semesterHours = 6;
    t.gpa      = 1.0;    // not doing so good
    t.addCourse(3, 1.5); // things aren't getting
                         // much better

    system("PAUSE");
    return 0;
}

s.addCourse(3, 2.5)

 is like

Student::addCourse(&s, 3, 2.5)

float Student::addCourse(int hours, float
         grade)
{
    float weightedGPA;
    weightedGPA = this->semesterHours *
    this->gpa;

    // now add in the new course
    this->semesterHours += hours;
    weightedGPA += hours * grade;
    this->gpa = weightedGPA / this-
          >semesterHours;
    return this->gpa;
}

The :: between a member and its class name is called the scope resolution operator because it indicates the class to which a member belongs. The class name before the colon is like the family last name, while the function name after the colons is like the first name — the order is similar to a Chinese name, family name first.

You use the :: operator to describe a nonmember function by using a null class name. The nonmember function addCourse, for example, can be referred to as ::addCourse(int, float), if you prefer. This is like a function without a home.

Normally the :: operator is optional, but there are a few occasions when this is not so, as illustrated here:

// addCourse - combine the hours and grade into
//             a weighted grade
float addCourse(int hours, float grade)
{
    return hours * grade;
}

class Student
{
  public:
    // add a completed course to the record
    float addCourse(int hours, float grade)
    {
        // call some external function to calculate the
        // weighted grade
        float weightedGPA= ::addCourse(semesterHours,gpa);

        // now add in the new course
        semesterHours += hours;

        // use the same function to calculate the weighted
        // grade of this new course
        weightedGPA += ::addCourse(hours, grade);
        gpa = weightedGPA / semesterHours;

        // return the new gpa
        return gpa;
     }

     int  semesterHours;
     float gpa;

};

Here, I want the member function Student::addCourse() to call the nonmember function ::addCourse(). Without the :: operator, however, a call to addCourse() from Student refers to Student::addCourse(). This would result in the function calling itself.

A member function can be defined either in the class or separately. When defined in the class definition, the function looks like the following, which is contained in the include file Savings.h:

// Savings - define a class that includes the ability
//           to make a deposit
class Savings
{
  public:
    // define a member function deposit()
    float deposit(float amount)
    {
        balance += amount;
        return balance;
    }

    unsigned int accountNumber;
    float  balance;
};

Using an include like this is pretty slick. Now a program can include the class definition (along with the definition for the member function), as follows in the venerable SavingsClass_inline program:

//
//  SavingsClassInline - invoke a member function that's
//                       both declared and defined within
//                       the class Student
//
#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;
#include "Savings.h"

int main(int nNumberofArgs, char* pszArgs[])
{
    Savings s;
    s.accountNumber = 123456;
    s.balance = 0.0;

    // now add something to the account
    cout << "Depositing 10 to account "
         << s.accountNumber << endl;
    s.deposit(10);
    cout << "Balance is " << s.balance << endl;

    // wait until user is ready before terminating program
    // to allow the user to see the program results
    system("PAUSE");
    return 0;
}

This is cool because everyone other than the programmer of the Savings class can concentrate on the act of performing a deposit rather the details of banking. These details are neatly tucked away in their own include files.

For larger functions, putting the code directly in the class definition can lead to some large, unwieldy class definitions. To prevent this, C++ lets you define member functions outside the class.

When written outside the class declaration, the Savings.h file declares the deposit() function without defining it as follows:

// Savings - define a class that includes the ability
//           to make a deposit
class Savings
{
  public:
    // declare but don't
    float deposit(float amount);
    unsigned int accountNumber;
    float  balance;
};

The definition of the deposit() function must be included in one of the source files that make up the program. For simplicity, I defined it within main.cpp.

//
//  SavingsClassOutline - invoke a member function that's
//                        declared within a class but
//                        defined in a separate file
//
#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;
#include "Savings.h"

// define the member function Savings::deposit()
// (normally this is contained in a separate file that is
// then combined with a different file that is combined)
float Savings::deposit(float amount)
{
    balance += amount;
    return balance;
}

// the main program
int main(int nNumberofArgs, char* pszArgs[])
{
    Savings s;
    s.accountNumber = 123456;
    s.balance = 0.0;

    // now add something to the account
    cout << "Depositing 10 to account "
         << s.accountNumber << endl;
    s.deposit(10);
    cout << "Balance is " << s.balance << endl;

    // wait until user is ready before terminating program
    // to allow the user to see the program results
    system("PAUSE");
    return 0;
}

This class definition contains nothing more than a prototype declaration for the function deposit(). The function definition appears separately. The member function prototype declaration in the structure is analogous to any other prototype declaration and, like all prototype declarations, is required.

Notice how the function nickname deposit() was good enough when the function was defined within the class. When defined outside the class, however, the function requires its extended name, Savings::deposit().

Member functions can be overloaded in the same way that conventional functions are overloaded. (See Chapter 6 if you don't remember what that means.) Remember, however, that the class name is part of the extended name. Thus, the following functions are all legal:

class Student
{
  public:
    // grade -- return the current grade point average
    float grade();
    // grade -- set the grade and return previous value
    float grade(float newGPA);
    // ...data members and other stuff...
};

class Slope
{
  public:
    // grade -- return the percentage grade of the slope
    float grade();
    // ...stuff goes here too...
};

// grade - return the letter equivalent of a number grade
char grade(float value);

int main(int argcs, char* pArgs[])
{
    Student s;
    s.grade(3.5);        // Student::grade(float)
    float v = s.grade(); // Student::grade()

    char c = grade(v);   // ::grade(float)

    Slope o;
    float m = o.grade(); // Slope::grade()
    return 0;
}

Each call made from main() is noted in the comments with the extended name of the function called.

When calling overloaded functions, not only the arguments of the function but also the type of the object (if any) with which the function is invoked are used to resolve the call. (The term resolve is object-oriented talk for "decide at compile time which overloaded function to call." A mere mortal might say "differentiate.")