Pointers, Arrays, and Strings

C++ has a string class, but the C-Language does not.

Understanding C-style strings is important, even if you plan to use the string class.

C-style strings are arrays of characters (char).

C-style strings must adhere to this rule: everything that process a C-style string knows to process it character-by-character until the EOS ('\0') character.

In C/C++ arrays are related to pointers, so we will need a brief introduction.

The C++ string Class

Note that unlike Java, the classname starts with a lower-case s (my top, number-one error when working in both languages!!).
When creating objects in C/C++, new is typically not used, unless dynamically allocated memory is required; usually it is not (more soon).
This makes the syntax for calling the constructor a bit strange if you are used to Java.
When an object is declared the constructor is automatically called.
There are 2 basic syntactical forms:
1. Declare the object - the default constructor is automatically called. For instance: string name;
2. Declare the object and specify the arguments directly in the declaration. For instance: string name("Cathy Bishop");
Note that this: string name(); does NOT call the default constructor.
It is not even a declaration. What kind of statement is it?
Here is documentation on the string class from cplusplus.com.

Note: C/C++ has the same concept of primitives we saw in Java, such as int, char, double, ...; like Java, they do not have constructors and will not be used with dot-notation.

Pointers

A pointer is an object that stores the address of an object (class) or variable (primitive).
To declare a pointer, put a * symbol in front of the variable name when it is declared.
The & symbol in front of a variable used as a reference means "address of".
The * symbol in front of a variable used as a reference means "contents of".
The term indirection means to follow a pointer and referencing the value that is stored in the address stored in the pointer.
This is also called dereferencing the pointer.
Note: A pointer is not the same as a reference. C++ has both and we will contrast them with Java, which only has references.
For instance, indirection with references (like in Java) is done automatically. With pointers you must explicitly de-reference them with the *.

Pointers and Arrays

The address of an array is the address of the first element in the array.
Using an array by itself in a reference is really the address of the first element.
Often, pointers are used when working with arrays, especially character arrays (C-style strings).

Arrays of Characters

One of the most common examples of using pointers with arrays is in string-manipulation, because a C-style string is really an array of characters.
The last character that is set in the array must be an end of string (EOS). This is the character '\0'.
Because the end of string character must be stored, the size of a character array must be one more than the length of the biggest string to be stored.

Here is a code example:


// Both of these declare an array of 12 characters

char	*string1 = "this is fun";
char	string2[12];

char	*strptr;

// The string "Hi" is copied into string2 and printed

strcpy(string2, "Hi");
cout << string2 << endl;

// strptr is assigned the address of string1 

strptr = string1;

// "this is fun" is printed twice

cout << strptr << endl;
cout << string1 << endl;

// what is printed next?

strptr = &(string1[8]);
cout << strptr << endl;

What does this code do?


char	*string1 = "this is fun";
char	string2[7];
char	*string3 = "Hello";
char	*strptr = string2;

strcpy(string2, string3);
cout << string2 << endl;

cout << string3 << endl;

strcpy(strptr, string1);
strcpy(string1, string3);
cout << string2 << endl;
cout << strptr << endl;