This example is somewhat different from the approach we took in class. In particular, in this implementation I have made the decision not to allocate space if the String object is empty. This tends to make more work for us because we now have to check to size of the String before we deallocate memory. Also, I decided to use a typedef statement to define szType to hold the type of object used to hold the length of the String. This has an advantage in that I can modify the type quite easily (for example, if we decided that we needed to deal with really long strings, we could make szType by a long unsigned int instead of an unsigned int).

The above two lines (along with the #endif at the end of the header file) ensure that this class is not inadvertently declared twice.

This has the potential for happening if String.h were included twice in one source file. While this may seem unlikely, it really isn't. For example, suppose you had Date class that stored the day of the week as a String. You would need to include String.h in the Date.h header file. In the source file containing main, you would probably include String.h and Date.h since you would want to create String and Date objects inside main. Doing so results in String.h being included twice (once explicitly and another time by way of the Date.h file which included String.h in it).

This statement allows us to use szType in place of unsigned int. You should notice that this has been declared within the String class which means that if we want to use it outside of the String class member functions, we need to use its full name: String::szType.

Note that we return by reference instead of by value. We do this because it is more efficient and because we know that the reference will be valid even after the function call is complete. We know this because the only way we can call this function is to have a valid String object. It is a reference to this object that gets returned.

Here we use szType instead of unsigned int.

We have two versions of the subscript operator. This function returns an rvalue, i.e., a value that can only appear on the right side of an assignment operator. This function gets called whenever we have a const String object. It is necessary because the non-const version cannot be called on a const String object. This actually happens quite frequently... consider the following function:

void printMe(const String& word)
{
  for(String::szType i=0; i<word.size(); ++i)
    cout << word[i];
  }
}

Because word is passed in by const reference, word can only call const member functions. Without this version of the subscript operator, the printMe function would not compile. It should also be noted that the size member function needs to be declared const for the same reason.

One final thing to notice is the way we had to specify String::szType. We have to do it this way because szType was declared within the String class and the printMe function is not part of the class.

This version actually allows us to change the values of characters within the String object. This function returns a lvalue, i.e., a value that can appear on either the left or right side of an assignment operator.

It is not anticipated that this function would ever be called directly. However, we need it be declared public because it will be called by the auxillary function operator<<.

An alternate approach would be to declare the operator<< function to be a friend of the String class. This would be done by replacing the insertion member function prototype with the following:

This would allow operator<< to have access to the private members in the String class. We prefer writing the insertion function since we can declare the function a const function.

This operator returns a reference to an ostream so that it is possible to multiple stream instertions on the same line. For example, if os is an ostream and a, b, and c are String objects,

  os << a << b << c;

will send a, b, and c to the output stream, os.

The above function makes use of an initializer list. It is the preferred method for assigning values to data members as it gives the data member a value when it is created rather than creating it with some invalid value and then going back and giving it the appropriate value.

This statement allocates space for a character array with numEl elements and causes letters to point to it. Note that if numEl = 0, then no memory is allocated.

This function is slightly more complicated that the copy constructor because here we don't know how many characters are in str. We need to loop through the character array until we find the null character, '\0'.

The if statement above makes sure that we don't assign an object to itself. this is a pointer to the calling object, i.e., it is the address in memory where the calling object resides. rhs is the object whose value we want to copy and &rhs the address in memory where it is stored. If this and &rhs are the same, then they are both stored in the same place in memory and must be the same object. In this case, not checking for self-assignment is inefficient. Suppose that A is a String object and we do the following: A = A;. This function is called with the calling object being A and the object passed in, rhs, also being A. Therefore, numEl and rhs.numEl are the same and letters and rhs.letters both point to the same character array. Without the self assignment check, we would be forced to copy all of the letters into the same location, clearly inefficient.

It is important to check for self assignment whenever implementing the assignment operator for a class that has dynamically allocated memory. In this case are implementation would be less efficient; however, there are situations where it can be down right disastrous. For example, we could remove the if statement immediately following this comment and still have a valid implementation of the assignment operator (it's just a little less efficient when assigning two Strings of the same length equal to each other); however, now if we were to remove the self assignment check as well, we would have major problems. Can you see why?

Removing the two if statements would result in us deallocating the memory used to store the calling object. We would then allocate new memory to store the character array from rhs, but when we tried to copy the characters from rhs we would discover that they are no longer there (we just deleted them).

Here we add the contents of rhs to the calling object. This requires us to allocate enough memory to store both Strings, copy the contents of the calling String to the newly allocated memory, then copying the contents of rhs, deallocating the memory that stored the original calling object, and make the letters data member point to the newly allocated memory.