Strings: Lesson

An array containing the characters of "Hello World"

Your very first exercise in this course was the traditional task of printing the line “Hello World” to the screen. In this lesson, we will dive deeper into the data type of “Hello World” and explore its properties and functions. In C, the line “Hello World” is known as a *string* as it is simply a string of characters. Strings are very important in programming and software engineering as they allow the program to display output to the user and can even be used to debug errors. In the C programming language, a string is represented by an array of `char`s and is consequently subject to all the properties and methods associated with arrays. The most common function used with strings is the `printf()` function as you have seen before.

Introduction to Strings

Just like with arrays, we can also loop through a string to access or modify its characters! You can use a `while` loop or a `for` loop, but in most cases, a `for` loop is much more convenient. Here is an example of looping through a string:
```cpp
char str[] = "Hello World";

for(int i = 0; i < 11; i++) { 
  printf("%c", str[i]);
}
```
This code will loop through the string "Hello World" and print the characters to the screen. Note that in a loop, you do not need to account for the null terminating character as it is unlikely you will need to use it.

However, there is a small problem with this code. The `for` loop hard codes the length of the string (11 in this case) in the condition statement. Writing loops in such a way presents a problem as the length of the string is rarely known beforehand and makes this loop valid only for strings with 11 characters! To remedy this problem and make the loop valid for strings of any length, we can use the `strlen()` function. This function determines the length of the string. It is used like so:

> `strlen(str)`

The `strlen()` function is a special string function contained in the string library. To use it, the code must include the following line at the top of the file:

>`#include<string.h>`

The example code from above can now be written like this:

```cpp
#include<stdio.h>
#include<string.h>

int main() {
  char str[] = "Hello World";

  for(int i = 0; i < strlen(str); i++) { // Using strlen instead of hard coding the string length
    printf("%c", str[i]);
  }
}
```

Note that `strlen()` does not account for the null terminating character.

Looping Through Strings

The characters of a string are accessed using the same methods as those for a regular array. It's important to note that since strings are arrays of characters, they are subject to all of the same constraints as an array. This means a string cannot be extended to add new characters, and a character in a string cannot be deleted!

Recall from the lesson on arrays that an element in an array is accessed like so:

> `arr[idx]` 

In the case of strings, the index, `idx`, represents the character at that index. And just like arrays, the *n*th character is at index `n-1`. Here is an example:

```cpp
char str[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0'};
char str2[] = "Hello World";

printf("%c\n", str[6]); // "%c" required to instruct printf() that it is to expect a character.
printf("%c", str2[6]);
```

The code above creates the string "Hello World" in both ways. `str[6]` and `str2[6]` will access the character at index six, which is the seventh character in both strings, respectively. In this case, this character is `'W'`, which is the same for both strings since they are identical.

Modifying a character in a string is done in the same way as modifying an element in an array regardless of how the string was created:

> `arr[idx] = newValue`

In the case of strings, `newValue` represents the new character to be placed. Remember, that it is not possible to add characters or delete them. Here is an example:

```cpp
char str[] = "Hello Yorld";
printf("%s\n", str); // This will print Hello Yorld to the screen

str[6] = 'W'; // Replace 'Y' with 'W'
printf("%s\n", str); // This will print Hello World to the screen
```


Character Access and Modification

Creating a string can be done in one of two ways. The first way is to simply create an initialized array of characters populated by the characters of the string. Here's an example of the string  "Hello World" created using an initialized array:

```cpp
char str[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0'};
```

The character array is populated by the characters of "Hello World." There are two important things to note here:
* A blank space is a character, so it is included by putting a space in single quotes.
* The very last character in the array is `\0` known as the null terminating character. It signifies the end of the string and must be included when creating a string as an initialized array. 

The string "Hello World" has 11 characters in it (space is a character too!) but the size of `str[]` is 12: 11 characters for "Hello World" plus one for the null character.

The second way to create a string variable in C is to use what is called a *string literal*. This is the creation of a string by initializing the `char` array with the full string in double quotes like so:

```cpp
char str[] = "Hello World";
```

This is still an array of characters and is to be treated as such. The only benefit to creating a string in this way is that it's easier to type and the null terminating character ('\0') is added implicitly. The size of this array is still 12 for the same reasons mentioned before.

Using the `printf()` function to print the string is done by providing the name of the string (array), regardless of how it was created, and `"%s"` to signify that `printf()` is working with a string. Here is an example:
 ```cpp
char str[] = "Hello World";
printf("%s", str); // This will not print a new line
printf("%s\n", str); // This will print a new line
```

Note: Characters in C are case-sensitive; i.e., the characters 'A' and 'a' are treated as two different kinds of characters.


Creating and Initializing Strings

Just like there exists a function for strings that returns its length (`strlen()`), the string library contains other useful string functions. In this exercise, we will explore how to concatenate two strings together using the `strcat()` function.

The `strcat()` function takes one string, `src`, and appends it to the end of another string, `dst`. Using this function does not create a separate third string, but modifies the `dst` string to include the `src` string at the end. The syntax for this is:

>`strcat(dst, src);`

At first glance, it may appear that some magic has taken place here because it is known that strings (because they are arrays) are immutable! What actually happens is the function takes the two strings and creates a char array of size `strlen(src) + strlen(dst) + 1`. It then populates the array with the characters of both strings starting with `dst`. Finally, it discards the memory occupied by the original `dst` string and associates the `dst` string variable with the new char array created. This is all done for you "under the hood" using the concept of pointers, a topic that will be discussed in a future lesson.  

Here it is in action:

```cpp
#include<stdio.h>
#include<string.h> // Don't forget to include this!

int main() {
  char s1[] = "abcd";
  char s2[] = "efgh";
  strcat(s1, s2);
  printf("%s", s1); 
  // Output will be "abcdefgh"
}
```

Concatenating Strings

Array containing the characters in "string"

Congratulations on completing the lesson on strings in C! You are now capable of solving many problems that require string manipulation. Here is a brief review of everything you learned:

* In C, strings are simply arrays of the `char` data type.
* Since strings are arrays, they are subject to all the properties and constraints of an array.
  * You cannot change the size of a string.
  * You cannot delete characters from a string; only replace them.
  * Modifying a character in a string is done in the same way as modifying an element in an array.
  * You can loop through a string like you would an array.
* A string can be created in one of two ways:
  * The first being an array of `char`s: `char str[] = {'S', 't', 'r', 'i', 'n', 'g', '\0'};`
  * The second and more convenient is to use a string literal: `char str[] = "String";`
* An empty string of length `len`, is created like so: `char str[len];`
* All strings must end with the null terminating character '\0'.
  * This character _must_ be added manually when creating a string using the array method.
  * This character is automatically added when creating a string using a string literal.
* The length of a string is the number of characters it contains plus one to account for the null character.
* There exists a library in the C language that contains common functions that are used to operate on strings. The library is imported by including the line `#include<string.h>` at the top of the code.
* The `strlen()` function returns the number of characters in that string excluding the null terminator.
  * Syntax: `strlen(str);`
* The `strcat()` function concatenates two strings together.
  * Syntax: `strcat(dst, src);`
  * `strcat()` creates a new string of length strlen(src) + strlen(dst) + 1, containing all the characters of strings dst and src. The new string is assigned to the variable holding the original dst string. A separate third string is NOT created.
* The function `strcpy()`, copies an existing string into a new empty string.
  * The empty string must be long enough to accommodate the original string or else undefined behavior will occur.
Good work!


Review

In this exercise, we will take a look at the `strcpy()` function which is used to copy a string into an empty character array (empty string). The syntax for this function is this:

 >`strcpy(dst, src);`

Given a string `src` and an empty string (empty character array) `dst`, the `strcpy()` function copies the contents of the `src` string into the `dst` string. It is important that the size of the empty character array, `dst`, be greater than or equal to the length of the string `src` plus one for the null character ('\0') in order to accommodate all incoming characters. If the `dst` char array is too short, the program will exhibit undefined behavior. Similar to the `strcat()` function, a new string will not be created.

The following example illustrates the use of `strcpy()`:

```cpp
#include<stdio.h>
#include<string.h>

int main() {    
  char s1[] = "ABCD";
  char s2[5]; // Empty string of five characters
  strcpy(s2, s1);    
  printf("%s", s2); // Prints: ABCD
}
```