Wyo C++ Ch. 13 Notes

Objective #1: Understand various functions that can be used with built-in C++ character arrays.

You should be familiar with these string functions which work with built-in C strings (aka character arrays). However, in programming assignments for this class, you should only use apstring objects that are explained in these chapter notes.
To find a C string's (character array) actual length, you can use the strlen function. The statement,

stringLength = strlen(userString);

stores the actual length (number of printable characters) of the character array, userString, in the numeric variable, stringLength. Note that even though a character array may have been declared to a certain size, the string may not use up all of those character positions. That is, in the statement,

char userName[90] = "John";

only four of the 90 positions are used by printable characters and, of course, the null terminator takes another space. So, the length of userName is 4.

To compare two character array in order to see if they are exactly the same, you can use the strcmp function. So, for example,

if (strcmp(string1, string2) = = 0)
{
cout << "The strings are the same!\n";
}

causes the message to be printed on the screen if the two character arrays, string1 and string2, are equivalent. The strcmp function returns a negative value if the first character array is alphabetically less than the second and it returns a positive value if the second character array is alphabetically less than the first one. It returns a zero if and only if the two character arrays are exactly the same.

To combine two character arrays into one larger string is called "concatenation". To concatenate two character arrays, you can use the strcat function. If the character array, firstName, is "John" and the character array, secondName, is "Doe" then

strcat(firstName, secondName);

results in firstName becoming "JohnDoe" and secondName remains "Doe". Note that in order to include a space between the two parts of the name, you may need to do something like this:

strcat(firstName, " ");
strcat(firstName, secondName);

In order to use strlen, strcmp, and strcat, you must include the string.h library in a compiler directive at the top of your program.

Objective #2: Be able to use the apstring class.

The textbook uses the oostring class which is virtually the same as the apstring class which has been offered by the makers of the AP Computer Science exam. We will use the apstring class for all examples and programming assignments. Visit the AP Computer Exam Web site for official copies of those files. They are also available in our network template folder.

However, there is a larger class called string that is used by professional C++ programmers. These string classes provide additional features for strings beyond those found in the standard string header file that is "built-in" to C++. These classes are object-oriented in nature, unlike the built-in C strings (i.e. character arrays).
Generally every class should include a default constructor, which is used when the object is instanciated with no arguments. C++ will create a default constructor automatically but you should be in the habit of including a default constructor in any class that you define. In the apstring class, the default constructor

apstring( );

constructs an empty string. The default constructor allows you to instanciate an apstring object with the statement

apstring firstName("John");

as well as the more usual,

apstring firstName = "John";
A copy constructor is used when objects are passed to functions by value. That is, C++ must create a copy of the object in the memory (RAM) and must be supplied with a reference to the object which must be copied. Copy constructors may look confusing but if you examine one closely everything should make sense. In the case of the apstring class, the copy constructor

apstring(const char * s);

receives (as an incoming parameter) a pointer to a character array. Therefore, C++ knows what to duplicate in the computer's RAM. The copy constructor

apstring(const apstring & str);

also provides information that allows C++ to duplicate an apstring object. In this case though, it receives the address of another apstring object.
Accessor functions are member functions that access an object but do not change the private or public data found there. With regard to the apstring class, length, find, and substr are accessor functions.
Modifier functions are member functions that do change an object's data (public or private). With regard to the apstring class, the overloaded += operator is a modifier.
Operator overloading allows a programmer to use a standard C++ operator (eg. *, +, -, etc.) in a different way than it is originally defined. You must provide instructions in the class definition so that C++ knows exactly how to handle the overloaded operator in this new situation. Operators that are overloaded within the class definition are considered to be members of that class (just like member functions).
The statement const apstring & operator = ( const apstring & str ); overloads the assignment operator (=) so that a programmer can write statements like myName = yourName; where myName and yourName are apstring objects. Otherwise this assignment would be illegal since the assignment operator (=) is conventionally only defined and expected to be used with normal data types like int, float, char, etc.

Objective #3: Understand advanced object-oriented concepts used in the apstring class.

The const keyword is used in 3 different ways within the apstring class.
- The const keyword is used at the end of a member function definition header to specify that the member function's method should not change any member variables. Such member functions are called const member functions. A careful programmer would never have to use const in this way since he/she would not write code within a member function that changes member variables unless he/she was sure that he/she means to do so. But, it is common and wise for programmers to use const to make "constant member functions" to avoid logic errors. A syntax error will result if you do accidentally try to modify member variables within a constant member function. It is common to use const in this way in accessor functions whose only purpose is to "retrieve" data anyway.
  
  For example, it is used in this way with apstring's length member function:
  
  int length( ) const;
  
  This prevents the programmer who wrote the length function from accidentally changing the value of any apstring member variables (such as myLength or myCapacity).
- It is used within the parameter list of a function. This is done in apstring's find member function:
  
  int find( const apstring & str ) const;
  
  where the incoming parameter str is being passed to the find member function by reference. Passing an apstring by reference is advisable because it is memory efficient and faster than passing a potentially large apstring object by value. But, if the programmer really doesn't intend to modify the actual value of str, then he should use const in this way. Using const here will cause a syntax error to occur if he accidentally writes code within the find function that accidentally modifies str, thus providing a check against his own mistakes or sloppy programming.
- It is used to keep the returned object from being modified within the call statement of the client program. In the overloaded assignment operator of the apstring class, const is used in this way,
  
  const apstring & operator = ( char ch );
  
  Consider a client program with the following code:
  
  apstring myInitial;
  (myInitial = 'P') = 'G';
  
  The assignment statement above is ambiguous and therefore disallowed by the use of const. The value returned as myInitial after the execution of the parentheses is 'P' but the use of const keeps it from being modified further when the second assignment operator is applied in the very same statement. This use of const would however allow two separate statements to assign different values to myInitial as in:
  
  myInitial = 'P';
  myInitial = 'G';
  
  It is common and wise to use const in this way when overloading assignment and compound operators.
A destructor is used to release the memory used by an object when it falls out of scope or is no longer needed. Usually, C++ will provide a destructor automatically even if one is not added to the class definition. (Similar to how a default constructor is added if the programmer doesn't do so explicitly.) A destructor is denoted by the use of the tilde (~) in front of the class name. For example, the prototype for the destructor to the apstring class is:

~apstring( );
The apstring class overloads several operators that already have uses in standard C++. For example, the assignment operator ( = ) is overloaded within the apstring class so that the statements,

myString = yourString;

and

myName = "John";

are valid. This allows a programmer to use the assignment operator in contexts that seem reasonable with apstring objects. Note that the assignment operator cannot be used to assign one character array to another. Rather the awkward strcpy function must be used.
The overloaded bracket operator is used as the subscript operator ( [ ] ) in the apstring class to allow a programmer to reference individual characters within an apstring. Bounds-checking is performed within this method so that a "nice" run-time error message appears when a programmer attempts to access and modify an out-of-range index position of an apstring. Note that neither built-in C++ character arrays nor strings from the C++ string class perform this kind of bounds-checking. The authors of the apstring class added this feature to make it easier to work with apstrings.
Overloading << and >> allows the programmer to use the insertion (i.e. output) and extraction (i.e. input) operators with apstrings. Otherwise the statement,

cout << myName;

would not be legal if myName were an apstring object.
The find member function of apstring is overloaded. An overloaded function is a function that can be used by specifying two or more different sets of parameters. The find function can be passed an apstring parameter or a character literal. The C++ compiler automatically detects which version of the function must be called depending on the parameters.
The keyword this is used within several member functions of the apstring class (as well as the methods of other classes) to refer to the object to which the function applies. For example, the statement return *this; is at the end of all of the overloaded operator functions in the apstring class and it returns the current object that the this object points to. Note that returning a pointer to an object (*this) saves memory since only a pointer variable is actually being returned. (Using return this; would pass the whole object.)
The function getline is a free function that is used with the apstring class. A free function is not included as part of a class definition. Therefore a free function is not a member function. But, the prototype for a free function may be placed in the .h file where a class definition is found so that the function can be used hand-in-hand with the class. The free function's definition is placed in the implementation .cpp file along with the function definitions for the member functions. However the scope specifier is not used in the function header for a free function since it is technically not part of the class.