C++ Classes

Contents

• Example C++ Class
• Constructor Functions
  • Test Yourself #1
• Two Useful Standard Classes: string and vector
  • string
  • vector
  • Test Yourself #2
• Classes with Pointer Data Members
  • Destructor Functions
    • Test Yourself #3
  • Copy Constructor Functions
    • Test Yourself #4
    • Declaration
    • Definition
  • Operator =
  • Wrap-up

C++ classes are similar to Java classes in many ways, but there are also important differences. Below is an example of a C++ class named IntList to be used to represent a list of integers; operations to add a value to the end of the list and to print the list are provided. The implementation uses a dynamically allocated array to store the integers; when the array is full, a new array of twice the size is allocated.

The code that defines the class would be split into two files: the first part specifies what member functions (methods) and data members (fields) the class will have. That code goes into a header file: a file with the extension .h. It is usually a good idea (though not a requirement as in Java) to give the file the same name as the class (so the file would be named IntList.h).

The second part of the class definition gives the code for the function bodies. That code goes in a source file (e.g., IntList.C).

The reason for splitting up the code is that it is generally a good idea to try to separate the interface from the implementation. Someone who wants to use an IntList really only needs to know what IntList operations are available; it is not necessary to know all the details about how an IntList is implemented. However, splitting up the code in this way is not required by C++. Some people prefer to include code for the member functions in the .h file when that code involves only one or two statements.

Here is the code that would be in IntList.h:

#include <iostream>

class IntList {
  public:
    IntList();                         // constructor; initialize the list to be empty
    void AddToEnd(int k);              // add k to the end of the list
    void Print(ostream &output) const; // print the list to output

  private:
    static const int SIZE = 10;      // initial size of the array
    int *Items;                      // Items will point to the dynamically allocated array
    int numItems;                    // number of items currently in the list
    int arraySize;                   // the current size of the array
};

• The class declaration must end with a semi-colon.
• The public and private members are grouped (as opposed to Java, where each method and each field is declared either public or private). It is generally considered a good idea to put the public members first, but that is not a C++ requirement.
• As in Java, the class's constructor function must have the same name as the class, and no return type (not even void).
• Function Print is declared to be a const function. In general, member functions that do not change any of the data members of the class should be declared const (this will be discussed further in the notes on parameter-passing modes).
• As in Java, a class can contain static data members. Every instance of the class will include its own copy of each of the non-static data members (e.g., each IntList object will include its own Items array, numItems integer, and arraySize integer), but there will be only one copy of each static data member for the whole class.
• Only static data members can be initialized as part of the class declaration. Other data members are initialized by the class's constructor function(s).

#include "IntList.h"

IntList::IntList(): Items(new int[SIZE]), numItems(0), arraySize(SIZE) {
}

void IntList::AddToEnd(int k) {
   ...
}

void IntList::Print(ostream &output) const {
   ...
}

• It is important to include the corresponding .h file; otherwise, you will get compile-time errors. In the #include, the name of the file is enclosed in quotes, not in angle brackets. Angle brackets are used for including standard library header files, and quotes are used for including your own header files.
• To tell the compiler that you are defining the member functions of the IntList class, you must prefix each function name with: IntList:: (note that this prefix comes after the function's return type).
• The definition of the IntList constructor uses a member initialization list to initialize the three fields. This is equivalent to the following code:

           IntList::IntList() {
               Items = new int[SIZE];
               numItems = 0;
               arraySize = SIZE;
           }
         

  In general, a member initialization list consists of a list of data member names with their initial values in parentheses, separated by commas. The initial value does not have to be a constant; it can be any expression. It is OK to initialize some data members in the member initialization list, and to initialize others using code inside the body of the constructor function. The member initialization list is executed before the body of the function, so if you initialize a data member in the member initialization list, it will already have its initial value inside the body of the constructor function.

  The main reason to use a member initialization list is when a data member is itself a class object, and you don't want the default initialization of that object. If you initialize the data member inside the body of the constructor function it will already have been initialized using its default (no-arg) constructor, which is a waste of time.

Constructor Functions

1. Extend the IntList class defined above by adding a member function called Length. The function should return the number of items currently in the list. Write the new declaration that would be added to IntList.h as well as the new code that would be added to IntList.C (write the complete code for the new function , not just ... as in the example).

2. Add a 2-argument constructor to the IntList class to allow an IntList to be initialized to contain n copies of value v. (So the two arguments are n and v, both of type int.) Again, write both the new declaration that would be added to IntList.h, and the new code that would be added to IntList.C.

The string class

• A string variable can be declared with or without an initial value:

  string s1;             // s1 is initialized to the empty string
  string s2("hello");    // s2 is initialized to the string "hello"
  string s3 = "goodbye"; // s3 is initialized to the string "goodbye"
  

• The string class provides a size function:

  string s1, s2 = "hello";
  cout << s1.size();         // s1's size is 0
  cout << s2.size();         // s2's size is 5
  

• Two strings can be compared using ==

  string s1("abc");
  string s2;
  s2 = "abc";
  if (s1 == s2) ...    // yes!  the two strings ARE equal
  

• Strings can be concatenated using the + operator

  string s1("hello");
  string s2("goodbye");
  string s3 = s1 + " and " + s2;  // the value of s3 is "hello and goodbye"
  

• The individual characters in strings can be accessed or updated using indexing (starting with 0), but you cannot index beyond the current length of the string.

  string s1 = "hello";
  for (int k=s1.size()-1; k>=0; k--) cout << s1[k];  // write s1 backwards
  for (int k=s1.size()-1; k>=0; k--) s1[k] = 'a';    // change s to "aaaaa"
  s[10] = 'a';                                       // ERROR! s only has 5 chars
  

The vector class

To use the vector class you must #include <vector>. A vector is similar to an array, but vectors provide some operations that cannot be performed using C++ arrays, and vectors can be passed both by value and by reference (unlike C++ arrays, which are always passed by reference). Unfortunately, there is no bounds checking for vectors (i.e., an index out of bounds does not necessarily cause a runtime error).

• A vector variable is declared with the type of its elements and its size; for example:

  vector <int> v1(10);  // v1 is a vector of 10 integers
  vector <char> v2(5);  // v2 is a vector of 5 characters
  

  The specified size can be any expression that evaluates to a non-negative value.

• Use indexing to access the elements of a vector as you would for an array:

  vector <int> v(10);
  for (int k=0; k<10; k++) {
      v[k] = 3;
  }
  

• The vector class provides a size function:

  vector <int> v1(10);
  vector <double> v2(5);
  cout << v1.size();         // v1's size is 10
  cout << v2.size();         // v2's size is 5
  

• The vector class provides a resize function:

  vector <int> v(1);
  v[0] = 10;
  v.resize(2*v.size());
  v[1] = 20;
  v.resize(1);
  

  The resize operation preserves as many of the old values as possible (so in the example, after the first resize operation, v[0] is still 10; after the second resize operation, v[0] is still 10, but there is no element of v equal to 20).

• Two vectors can be compared using == (they are equal iff they have the same size, and corresponding values are the same).

• One vector can be assigned to another using = (the types of the two vectors must be compatible; e.g., if the vectors are named v1 and v2, the assignment v1 = v2 is OK iff the assignment v1[0] = v2[0] is OK). The size of the vector being assigned to doesn't matter; it is changed after the assignment to be the same as the size of the vector being assigned from (for example, if v1.size() == 2, and v2.size() == 10, the assignment v1 = v2 is fine -- after it is executed, v1.size() == 10). Assigning from one vector to another does not introduce aliasing; for example, after the assignment v1 = v2, changing an element of v1 has no effect on v2 (or vice versa).

• A function can return a vector (a function cannot return a C++ array).

  vector <int> f( ) { ... }
  

• A vector can be passed by value or by reference (a C++ array is always passed by reference).

  void f( vector  A );  // A is passed by value
  void f( vector  &B ); // B is passed by reference
  

1. Write a function named NonEmpty that has one parameter, a vector of strings V, and that returns another vector of strings that contains just the non-empty strings in V. For example, if parameter V contains the 6 strings:
   "hello", "", "bye, "", "", "!"
   then function NonEmpty should create and return a vector that contains the 3 strings:
   "hello", "bye, "!"

2. Write a function named Expand that has one parameter, a vector of ints V. Expand should change V so that it is double its original size, and contains (in its first half) the values that were originally in V.

   Test your function with the following main function:

   #include <iostream>
   #include <vector>
   
   int main() {
     vector  v(1);
     
     for (int k = 1; k <= 16; k++) {
       if (v.size() < k) {
         cout << "vector size before calling Expand: " << v.size() << endl;
         Expand(v);
         cout << "vector size after calling Expand: " << v.size() << endl;
       }
       v[k-1] = k;
     }
     cout << "[ ";
     for (int k = 0; k < v.size(); k++) {
       cout << v[k] << ' ';
     }
     cout << "]\n";
     return 0;
   }
   

   When you run this program, the output should be:

   vector size before calling Expand: 1
   vector size after calling Expand: 2
   vector size before calling Expand: 2
   vector size after calling Expand: 4
   vector size before calling Expand: 4
   vector size after calling Expand: 8
   vector size before calling Expand: 8
   vector size after calling Expand: 16
   [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ]
   

Classes with Pointer Data Members

Every class that has a pointer data member should include the following member functions:

1. a destructor,
2. a copy constructor,
3. operator= (assignment)

class IntList {
  public:
    IntList();                         // constructor; initialize the list to be empty
    ~IntList();                            // destructor
    IntList(const IntList &L);             // copy constructor
    IntList & operator=(const IntList &L); // assignment
    void AddToEnd(int k);              // add k to the end of the list
    void Print(ostream &output) const; // print the list to output

  private:
    static const int SIZE = 10;      // initial size of the array
    int *Items;                      // Items will point to the dynamically allocated array
    int numItems;                    // number of items currently in the list
    int arraySize;                   // the current size of the array
};

Destructor Functions

An object's destructor function is called when that object is about to "go away"; i.e., when:

1. a class object (a value parameter or a local variable) goes out of scope, or
2. a pointer to a class object is deleted (the dynamically allocated storage pointed to by the pointer is freed by the programmer using the delete operator)

For example, consider the following function, with line numbers included for reference:

[1]  void f(IntList L) {
[2]    IntList *p = new IntList;
[3]    while (...) {
[4]      IntList L1;
[5]      ...
[6]    }
[7]    delete p;
[8]  }

The scope of variable L1 is the body of the while loop (lines 4 to 6). L1's constructor function is called at the beginning of every iteration of the loop, and its destructor function is called at the end of every iteration of the loop. Note that if the loop included a break or continue statement, the destructor would still be called.

Variable p is a pointer to an IntList. When an IntList object is allocated using new at line 2, that object's constructor function is called. When the storage is freed at line 7, the object's destructor function is called (and then the memory for the Intlist itself is freed).

Why isn't the destructor function of a reference parameter called at the end of the function?

Destructor functions are defined using syntax similar to that used for the constructor function (the name of the class followed by a double colon followed by the name of the function). For example, the definition of the Intlist destructor function would look like this:

IntList::~IntList() {
  delete [] Items; // free the dynamically allocated array pointed to by Items
}

NOTE: If you don't write a destructor function for a class that includes pointers to dynamically allocated storage, your code will still work, but you will probably have some storage leaks.

To understand more about storage management and destructor functions, let's consider a simpler version of the example code give above:

[1]  void f() {
[2]    IntList *p = new IntList;
[3]      ...
[4]    delete p;
[5]  }

p: ---------> +---------------+
              |               |    +---+
              | Items: ----------> | 2 |
              |               |    |---|
              | numItems: 10  |    | 6 |
              |               |    |---|
              | arraySize: 10 |    |   |
              |               |    |...|
              +---------------+    |   |
                                   +---+

Copy Constructor Functions

An object's copy constructor is called (automatically, not by the programmer) when it is created, and needs to be initialized to be a copy of an existing object. This happens when an object is:

1. passed as a value parameter to a function,
2. returned (by value) as a function result,
3. declared with initialization from an existing object of the same class.

1. actual parameter,
2. value being returned,
3. existing object.

Example

Here are two functions that illustrate when copy constructors are called:

[1]   IntList f( IntList L );
[2] 
[3]   int main() {
[4]     IntList L1, L2;
[5]     ...
[6]     L2 = f( L1 );               // copy constructor called here to copy L1
[7]   }
[8] 
[9]   IntList f( IntList L ) {
[10]    IntList tmp1 = L;           // copy constructor called here to copy L
[11]    IntList tmp2(L);            // copy constructor called here to copy L
[12]    ...
[13]    return tmp1;                // copy constructor called here to copy tmp1
[14]  }

On line 6, variable L1 is passed as a value parameter to function f. The corresponding formal parameter is L. When the call is executed, L's copy constructor is called to initialize L to be a copy of the actual parameter, L1.

On line 10, variable tmp1 is declared to be an IntList, initialized to be the same as variable L. When line 10 is executed, tmp1's copy constructor is called to initialize tmp1 to be a copy of L. Similarly, when line 11 is executed, tmp2's copy constructor is called to initialize tmp2 to be a copy of L.

On line 13, variable tmp1 is returned as the result of calling function f. When line 13 is executed, a copy constructor is called to make a copy of tmp1 to be returned. (Later, that copy is used as the right-hand side of the assignment on line 6.)

If you don't write a copy constructor, the compiler will provide one that just copies the value of each data member. If some data member is a pointer, this causes aliasing (both the original pointer and the copy point to the same location), and may lead to trouble. For example, consider the following code:

void f(IntList L) {
  L.AddToEnd(11);
}

int main() {
  IntList I;

  for (int k=1; k<11; k++) I.AddToEnd(k);
  // I's array "Items" is now full
  f(I);
  ...
}

   +---------------+
   |               |     +----+
I: | Items: -----------> |  1 |
   |               | +-> |----|
   |               | |   |  2 |
   | numItems: 10  | |   |----|
   |               | |   |  3 |
   | arraySize: 10 | |   |----|
   +---------------+ |   |  . |
                     |   |  . |
   +---------------+ |   |  . |
   |               | |   |----|
L: | Items: ---------+   | 10 |
   |               |     +----+
   |               |
   | numItems: 10  |
   |               |
   | arraySize: 10 |
   +---------------+  

Consider the StrList class defined below. A StrList stores a list of strings in a linked list pointed to by the StrList's head field. The Lookup operation determines whether a given string is in the list; if it is there, it is moved to the front of the list, and the value true is returned (otherwise, the list is unchanged, and the value false is returned).

class StrList {
  public:
    // constructor
    StrList();

    // modifiers
    void AddToFront(string s);
    bool Lookup(string s);

    // other operations
    void Print(ostream &output) const;

  private:
    struct ListNode {
       string data;
       ListNode *next;
    };
    
    // pointer to the first node of the list
    ListNode *head;
};

void f(StrList L) {
  L.Lookup("b");
}

int main() {
  StrList S;

  S.AddToFront("c"); S.AddToFront("b"); S.AddToFront("a");
  // S.head points to the linked list:
  //     "a" -> "b" -> "c"
  f(S);
  ...
}

The Copy Constructor Declaration

The Copy Constructor Definition

Operator=

In C++ you can assign from one class object to another (of the same type). For example:

IntList L1, L2;
...
L1 = L2;  // this assignment is OK

L1.Items = L2.Items;
L1.numItems = L2.numItems;
L1.arraySize = L2.arraySize;

If a class includes pointer fields, the default class assignment causes aliasing, and as we have seen in the case of the copy constructor, this can lead to trouble! For example, if the L2.Items array is full when the assignment is done, then a subsequent call to L1.AddToFront will cause the array to be returned to free storage (so L2.Items will become a dangling pointer).

The default assignment can also cause storage leaks when the class has a pointer field. For example, when L1 = L2; is executed, L1.Items is simply overwritten with the value in L2.Items, the array that L1 was pointing to is not returned to free storage (and that storage is now lost).

To prevent these problems, you should always define operator= as a class member function for a class with a pointer field. The declaration of the member function looks like this for the IntList class:

IntList & operator=(const IntList &L);

Note that IntList's operator= function returns an IntList. This is to permit chained assignment, for example: L1 = L2 = L3;. When this statement is executed, the expression L2 = L3 is evaluated first; the result of evaluating that expression is used as the right-hand side of the assignment to L1. The operator= function returns its result by reference (that's what the ampersand means). This is done for efficiency, to prevent the IntList copy constructor being called to make a copy of the returned value.

Note that operator= differs from the copy constructor in three important ways:

1. The object being assigned to has already been initialized; therefore, if it has a pointer field, the storage pointed to must be freed to prevent a storage leak.

2. It is possible for a programmer to assign from a variable into itself; for example: L1 = L1. The operator= code must check for this case, and do nothing.

3. The operator= code must return a value.

Here is the definition of operator= for the IntList class:

IntList & IntList::operator=(const IntList &L) {
  // check for "self assignment" and do nothing in that case
  if (this == &L) return *this;
  else {
    delete [] Items;                // free the storage pointed to by Items
    Items = new int[L.arraySize];   // allocate a new array
    arraySize = L.arraySize;        // set the arraySize field

    // copy the items from L's array to the new array
    // also sets the numItems field
    for (numItems=0; numItems < L.numItems; numItems++) {
      Items[numItems] = L.Items[numItems];
    }

    return *this;                   // return this IntList
    
}