A String Class: Part I - Lab

The Problem

Using arrays of characters to store strings in sufficient for basic operations performed on strings; however, there are problems that a simple array representation does not address. Here are some categories of problems, with an example for each:

Errors

Example: Because strings are stored in arrays, it is possible to attempt to access locations outside of the memory allotted to the string:
char label[10] = "value";
label[-1] = 'a';   // Eeek!
label[200] = 'z';  // No such location here!
Such attempts access memory that the code shouldn't, and may cause the program to crash.

Static

Example: A string cannot easily grow. In other words, without doing some dynamic allocation, the maximum size of a string is predetermined:
char label[10] = "value";
...
// Not enough room, though it will attempt it anyhow!
strcpy(label, "How now brown cow?");

Unnatural/Inconvenient

Example: Using library functions with strings is not terribly natural:
if (strcmp(label1, label2) > 0)  // Ugh!
  strcpy(label1, label2);
It would be more natural to be able to do:
if (label1 > label2)  // Ahhhh...
  label1 = label2;

Inefficient

Example: Determining the length of a string is inefficient in that it takes more time to find the nul character (\0) the longer the string:
char name[] = "my name";
char dict[] = <Insert the contents of the dictionary here>;

cout << "My name is " << strlen(name)  // Fast
     << " characters long." << endl;

cout << "The dictionary is " << strlen(dict)  // La, la, la...
     << " characters long." << endl;

The Solution

In this lab exercise, we will attack specific problems of:

error checking (e.g., making sure one cannot access elements outside a string) and
efficiency (e.g., in how the length of a string is acquired).

We'll leave the other problems to a future exercise.

A Class

C++ allow us to create new data structures (i.e., something with data and functionality) and wrap it up into a neat package called a class:

class String {
  // FUNCTIONS (OR "METHODS")
  //  - allowing a user of the string to set up, access or
  //    change the string.

  // DATA
  //  - needed to store the contents of the string and any other
  //    values that assist in our representation of the string.
};

By defining such a String class, we can solve our two problems:

Range Checking - We can prevent people using a String from accessing elements that are outside the actual string stored in the array. We must make the array a "private" part of the class, and only allow access to it via methods that we add to the class. Those methods can do any needed error checking.
Efficient Length - We can prevent traversing a string (i.e., looking for the nul character) every time we need its length. Instead, we can add a length field to our representation of a string (i.e., in addition to the array that holds the string's contents). Since a String will only be accessed via methods in the String class, those methods need only update the length when the string is changed. Then, asking a String for its length will only require the object to access one piece of data, the length field.

Your Task

You must write a String class that performs some range checking and efficient determination of length, and that provides some other basic functionality.

Your String class will have the following design:

Modularity
The String class code must be put in its own module, i.e., a file mystring.h (the header file) should hold the class definition and a file mystring.cpp (the implementation file) should hold the method definitions.
Data
Each String object should contain the following data as part of its internal representation:
- an array of characters of (sufficient) fixed length to store a string.
- a length field that will hold the current length of the string at any given moment.
Functionality
The String class should provide the following methods for setting up, accessing and changing strings:
- ```
String();
```
  A default constructor that sets up the String to be an empty string.
- ```
void assign(const char s[]);
```
  A method that copies the contents of the passed string into the String.
- ```
void append(const String &str);
```
  A method that appends the contents of the passed String onto the end of the String the method is called on.
- ```
int compare_to(const String &str) const;
```
  A method that compares the String this method is called on with the String passed to the method. If the string is greater than the string passed, it should return a positive value; if less than, a negative value, and if equal, the value zero.
- ```
void print() const;
```
  A method that prints the value of the String it is called on to cout.
- ```
int length() const;
```
  A method that returns the length of the String that it is called on.
- ```
char element(int i) const;
```
  A method that returns the ith element (zero-based, just like arrays) of the String it is called on. This method should print out an error message and return the nul character (\0) if the location asked for is out-of-range for the string.

In your implementation of String's methods, you may use the library functions provided by string.h, which operate on arrays of characters terminated by nul's (\0).

A Test Program

The file String-test.cpp provides a main program to test your new class.

Questions

In order to demonstrate an understanding of how to create and use a String class to represent strings, you should be able to define the following terms:

A string (in lowercase, i.e., the abstract concept)
The String class
A String object