Arrays and Strings in C++: Complete Chapter 5 Notes for Exam

5.1 Introduction to Arrays

Welcome to Chapter 5, class! You have learned variables, operators, loops, and control statements. Now I want you to think about a practical problem. Suppose you need to store the marks of 100 students. How would you do it using what you have learned so far?

You would need to write something like this:

int mark1, mark2, mark3, mark4, mark5, ... mark100;

That is 100 separate variables! Imagine trying to find the average — you would need to write mark1 + mark2 + mark3 + ... + mark100. What if you need 1000 values? This approach is simply impossible. This is exactly why arrays were created.

An array is a collection of elements of the same data type, stored in contiguous (adjacent) memory locations. Instead of 100 separate variables, you declare one array and access each element using an index number. It is like a row of lockers — each locker has a number (index), and all lockers are in a straight line (contiguous memory).

5.2 Array Definition

An array is a data structure that stores a fixed-size sequential collection of elements of the same type. The key characteristics are:

• Fixed size — once declared, the size cannot change during program execution.
• Same data type — all elements must be of the same type (all int, all float, all char, etc.).
• Contiguous memory — elements are stored next to each other in memory.
• Zero-based indexing — the first element is at index 0, the second at index 1, and so on.

5.3 Types of Arrays

Arrays are classified based on the number of dimensions (subscripts) they use:

1. One-Dimensional (1D) Array — has one subscript. Think of it as a single row or a list.
2. Multi-Dimensional Array — has two or more subscripts. The most common is the Two-Dimensional (2D) array, which you can think of as a table with rows and columns.

5.3.1 One-Dimensional Array

This is the simplest form of an array. A 1D array is essentially a list of values, all of the same type, accessed by a single index.

Declaration of a 1D Array

The general syntax for declaring a one-dimensional array is:

data_type array_name[size];

Let me explain each part:

• data_type — the type of each element (int, float, char, double, etc.)
• array_name — a valid C++ identifier (follows the same rules as variable names)
• size — the number of elements the array can hold. Must be a constant positive integer.

int marks[5];       // An array of 5 integers
float prices[10];   // An array of 10 floats
char name[20];      // An array of 20 characters
double scores[100]; // An array of 100 doubles

I want you to notice something important: when you write int marks[5];, you are telling the compiler to reserve space for 5 integers. But at this point, the array contains garbage values — whatever random data was in those memory locations. The array is NOT automatically filled with zeros!

Initialization of a 1D Array

Initialization means giving the array its initial values at the time of declaration. There are several ways to do this:

Method 1: Initialize all elements

int marks[5] = {85, 70, 92, 78, 88};

The values are placed inside curly braces { }, separated by commas. The first value (85) goes to index 0, the second (70) to index 1, and so on.

Method 2: Partial initialization

int marks[5] = {85, 70};

If you provide fewer values than the size, the remaining elements are automatically initialized to zero. So this array becomes: {85, 70, 0, 0, 0}.

Method 3: Let the compiler determine the size

int marks[] = {85, 70, 92, 78, 88};

If you omit the size, the compiler counts the number of values and sets the size automatically. Here, the compiler creates an array of size 5. This is convenient but only works when you initialize at declaration.

Method 4: Initialize all to zero

int marks[5] = {0};  // All five elements are 0

Placing a single 0 in the initializer sets all elements to zero. This is a common shortcut.

Accessing Array Elements

You access individual elements using the array name followed by an index inside square brackets [ ]:

int marks[5] = {85, 70, 92, 78, 88};

cout << marks[0];   // Output: 85 (first element)
cout << marks[2];   // Output: 92 (third element)
cout << marks[4];   // Output: 88 (fifth element)

marks[1] = 75;        // Change the second element to 75
cout << marks[1];   // Output: 75

int marks[5] = {85, 70, 92, 78, 88};
cout << marks[5];   // DANGER! Index 5 does not exist!
cout << marks[-1];  // DANGER! Negative index!

Memory Calculation for Arrays

The total memory occupied by an array depends on the size and the data type:

Worked Example 1: Read and Display Array Elements

#include <iostream>
using namespace std;

int main()
{
    int n, i;
    cout << "How many students? ";
    cin >> n;

    int marks[n];   // Declare array with user-defined size

    // Reading elements
    cout << "Enter " << n << marks:" << endl;
    for (i = 0; i < n; i++)
    {
        cin >> marks[i];
    }

    // Displaying elements
    cout << "\n--- Marks ---" << endl;
    for (i = 0; i < n; i++)
    {
        cout << "Student " << (i + 1) << ": " << marks[i] << endl;
    }

    return 0;
}

Notice how we use a for loop with i going from 0 to n-1. This is the standard pattern for accessing all elements of an array. The loop variable i serves as the index. We print (i + 1) for the student number because humans count from 1, but array indices start from 0.

Worked Example 2: Find the Sum and Average of Array Elements

#include <iostream>
using namespace std;

int main()
{
    int marks[5] = {85, 70, 92, 78, 88};
    int sum = 0;
    float average;

    for (int i = 0; i < 5; i++)
    {
        sum = sum + marks[i];
    }

    average = (float)sum / 5;

    cout << "Sum = " << sum << endl;
    cout << "Average = " << average << endl;

    return 0;
}
// Output: Sum = 413, Average = 82.6

Worked Example 3: Find the Largest Element in an Array

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {34, 89, 12, 67, 45};
    int largest = arr[0];   // Assume first element is largest

    for (int i = 1; i < 5; i++)
    {
        if (arr[i] > largest)
        {
            largest = arr[i];
        }
    }

    cout << "Largest element = " << largest << endl;
    return 0;
}
// Output: Largest element = 89

Here is the logic: we assume the first element is the largest. Then we compare it with every other element. If we find a bigger one, we update our “largest” variable. After checking all elements, largest holds the maximum value.

Why do we start the loop from i = 1 and not i = 0? Because we already used arr[0] as the initial value of largest. Comparing it with itself would be pointless — it would always be “not greater than” itself. Starting from 1 saves one unnecessary comparison.

Worked Example 4: Search for an Element (Linear Search)

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {34, 89, 12, 67, 45};
    int key, found = -1;

    cout << "Enter element to search: ";
    cin >> key;

    for (int i = 0; i < 5; i++)
    {
        if (arr[i] == key)
        {
            found = i;
            break;
        }
    }

    if (found != -1)
        cout << key << " found at index " << found << endl;
    else
        cout << key << " not found in the array." << endl;

    return 0;
}

This is called linear search — we check each element one by one from the beginning. If we find the element, we store its index and break out of the loop. If we finish the loop without finding it, we report “not found”. We use found = -1 as a flag because -1 is not a valid array index.

Array Manipulation Operations

Now let us look at common operations performed on arrays. These are very frequently tested in exams.

1. Inserting an Element

To insert an element at a specific position, you must first shift all elements from that position onward one position to the right to make space. Then place the new element.

#include <iostream>
using namespace std;

int main()
{
    int arr[6] = {10, 20, 30, 40, 50};  // size 6, currently 5 elements
    int n = 5;  // current number of elements
    int pos, value;

    cout << "Array: ";
    for (int i = 0; i < n; i++) cout << arr[i] << " ";

    cout << "\nEnter position to insert (0 to " << n << "): ";
    cin >> pos;
    cout << "Enter value: ";
    cin >< value;

    // Shift elements to the right
    for (int i = n; i > pos; i--)
    {
        arr[i] = arr[i - 1];
    }

    arr[pos] = value;  // Insert the new element
    n++;               // Increase element count

    cout << "After insertion: ";
    for (int i = 0; i < n; i++) cout << arr[i] << " ";

    return 0;
}

Notice the shifting loop goes backward — from n down to pos+1. Why? If we went forward, we would overwrite elements before we could shift them! By going backward, we safely move each element one position right. For example, to insert at position 2: arr[5]=arr[4], arr[4]=arr[3], arr[3]=arr[2], then arr[2]=new value. Each element is moved safely because we always read from a position that has not been overwritten yet.

2. Deleting an Element

To delete an element, you shift all elements after the deleted position one position to the left, overwriting the element to be deleted.

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;
    int pos;

    cout << "Array: ";
    for (int i = 0; i < n; i++) cout << arr[i] << " ";

    cout << "\nEnter position to delete (0 to " << (n-1) << "): ";
    cin >> pos;

    // Shift elements to the left
    for (int i = pos; i < n - 1; i++)
    {
        arr[i] = arr[i + 1];
    }
    n--;  // Decrease element count

    cout << "After deletion: ";
    for (int i = 0; i < n; i++) cout << arr[i] << " ";

    return 0;
}

For deletion, the shifting loop goes forward — from pos to n-2. Each element arr[i] is replaced by arr[i+1]. This overwrites the element at the deletion position and shifts everything left. After deletion, the logical size (n) decreases by 1, but the physical array size stays the same.

5.3.2 Multi-Dimensional Arrays

Sometimes data has more than one dimension. Think of a spreadsheet — it has rows AND columns. A chessboard has 8 rows and 8 columns. A classroom seating arrangement has rows and columns. For such data, we need multi-dimensional arrays.

A two-dimensional (2D) array is the most common type. You can think of it as an array of arrays — each element of the outer array is itself an array (a row).

Declaration of a 2D Array

data_type array_name[rows][columns];

int matrix[3][4];    // 3 rows, 4 columns = 12 integers
float table[2][3];   // 2 rows, 3 columns = 6 floats

Initialization of a 2D Array

// Method 1: Full initialization with nested braces
int matrix[2][3] = {
    {1, 2, 3},    // Row 0
    {4, 5, 6}     // Row 1
};

// Method 2: Without nested braces (filled row by row)
int matrix[2][3] = {1, 2, 3, 4, 5, 6};

// Method 3: Partial initialization
int matrix[2][3] = {{1, 2}, {4}};  // Becomes {{1, 2, 0}, {4, 0, 0}}

Accessing Elements of a 2D Array

int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};

cout << matrix[0][0];   // Output: 1 (Row 0, Column 0)
cout << matrix[0][2];   // Output: 3 (Row 0, Column 2)
cout << matrix[1][1];   // Output: 5 (Row 1, Column 1)

matrix[1][2] = 99;       // Change element at Row 1, Column 2

The first index is always the row, and the second is always the column: array[row][column].

Worked Example 5: Read and Display a 2D Array

#include <iostream>
using namespace std;

int main()
{
    int matrix[2][3];
    int i, j;

    // Reading elements
    cout << "Enter 6 elements (2 rows x 3 columns):" << endl;
    for (i = 0; i < 2; i++)        // outer loop: rows
    {
        for (j = 0; j < 3; j++)    // inner loop: columns
        {
            cin >> matrix[i][j];
        }
    }

    // Displaying elements
    cout << "\nMatrix:" << endl;
    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            cout << matrix[i][j] << "\t";
        }
        cout << endl;  // new line after each row
    }

    return 0;
}

See the pattern? We always use nested loops for 2D arrays. The outer loop handles rows, the inner loop handles columns. After the inner loop finishes (all columns of one row are printed), we use endl to move to the next line before the next row starts. This tab-separated format creates a neat table-like output.

Worked Example 6: Sum of All Elements in a 2D Array

#include <iostream>
using namespace std;

int main()
{
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int sum = 0;

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            sum += matrix[i][j];
        }
    }

    cout << "Sum of all elements = " << sum << endl;
    return 0;
}
// Output: Sum of all elements = 45

Worked Example 7: Sum of Diagonal Elements

#include <iostream>
using namespace std;

int main()
{
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int diagSum = 0;

    for (int i = 0; i < 3; i++)
    {
        diagSum += matrix[i][i];  // i == j for main diagonal
    }

    cout << "Main diagonal sum = " << diagSum << endl;
    return 0;
}
// Output: Main diagonal sum = 15 (1 + 5 + 9)

The main diagonal (also called principal diagonal) consists of elements where the row index equals the column index: [0][0], [1][1], [2][2]. For a square matrix (rows = columns), you only need one loop because i == j.

int m[2][2] = {{1, 2}, {3, 4}};
cout << m[0][1] + m[1][0];

5.3 String

5.3.1 String Definition

A string is a sequence of characters. In C++, there are two ways to work with strings:

1. C-style strings — arrays of characters terminated by a null character '\0'. This is the traditional C approach.
2. C++ string class — using the #include <string> library. This is the modern, easier approach.

In this course (following your module), we focus on C-style strings because they help you understand how strings work at the memory level. A C-style string is simply a character array where the last character is always a special null character '\0' (ASCII value 0) that marks the end of the string.

char str[5] = "Hello";  // WRONG! "Hello" needs 6 slots (5 chars + '\0')
char str[6] = "Hello";  // CORRECT
char str[] = "Hello";   // CORRECT — compiler auto-sizes to 6

5.3.2 String Declaration and Initialization

Method 1: Character by character

char name[6] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Must include '\0' manually!

Method 2: Using a string literal (recommended)

char name[6] = "Hello";    // Compiler automatically adds '\0'
char name[] = "Hello";     // Compiler sets size to 6 automatically

When you use double quotes "...", the compiler automatically appends the null terminator. This is much easier and less error-prone than Method 1.

Method 3: Declaration without initialization

char name[20];  // Declares space for 19 characters + '\0'
// Must be filled later using cin or assignment

Reading and Displaying Strings

#include <iostream>
using namespace std;

int main()
{
    char name[50];

    // Method 1: cin >> (reads only one word, stops at space)
    cout << "Enter your first name: ";
    cin >> name;
    cout << "Hello, " << name << endl;

    // Method 2: cin.getline() (reads entire line including spaces)
    char fullName[50];
    cout << "Enter your full name: ";
    cin.getline(fullName, 50);
    cout << "Hello, " << fullName << endl;

    return 0;
}

int age;
cin >> age;
cin.ignore();              // Clear the leftover newline
char name[50];
cin.getline(name, 50);    // Now works correctly

5.3.3 String Manipulation

C++ provides several useful functions for working with C-style strings in the <cstring> library. Let me explain each one with examples.

1. strlen() — String Length

Returns the number of characters in the string (NOT including the null terminator).

#include <iostream>
#include <cstring>
using namespace std;

int main()
{
    char str[] = "Hello";
    cout << "Length: " << strlen(str);  // Output: 5
    return 0;
}

Note: The string “Hello” has 5 characters. strlen does NOT count '\0'. The array size is 6, but the string length is 5.

2. strcpy() — Copy String

Copies the content of one string into another. The destination must be large enough.

char src[] = "Hello";
char dest[10];

strcpy(dest, src);   // dest now contains "Hello"
cout << dest;        // Output: Hello

// DANGER: Destination too small
char small[3];
strcpy(small, "Hello");  // Buffer overflow! "Hello" needs 6 chars

3. strcat() — Concatenate (Join) Strings

Appends one string to the end of another. The destination must have enough space for the combined string.

char first[20] = "Hello";
char second[] = " World";

strcat(first, second);   // first becomes "Hello World"
cout << first;           // Output: Hello World

4. strcmp() — Compare Strings

Compares two strings character by character based on ASCII values. Returns:

• 0 — if both strings are identical
• Negative value — if the first string is “less than” the second (comes earlier alphabetically)
• Positive value — if the first string is “greater than” the second

char s1[] = "Apple";
char s2[] = "Banana";
char s3[] = "Apple";

cout << strcmp(s1, s2);   // Negative (A < B in ASCII)
cout << strcmp(s2, s1);   // Positive (B > A in ASCII)
cout << strcmp(s1, s3);   // 0 (identical)

// Common usage in if-statements:
if (strcmp(s1, s3) == 0)
    cout << "Strings are equal";

char s1[] = "Hello";
char s2[] = "Hello";

if (s1 == s2)       // WRONG! Compares addresses, not content
    cout << "Equal";

if (strcmp(s1, s2) == 0)   // CORRECT! Compares content
    cout << "Equal";

5. strrev() — Reverse a String

char str[] = "Hello";
strrev(str);
cout << str;   // Output: olleH

6. strupr() and strlwr() — Convert Case

char str[] = "Hello World";
strupr(str);   cout << str;   // Output: HELLO WORLD
strlwr(str);   cout << str;   // Output: hello world

Worked Example 8: Count Vowels in a String

#include <iostream>
#include <cstring>
using namespace std;

int main()
{
    char str[100];
    int vowels = 0, i;

    cout << "Enter a string: ";
    cin.getline(str, 100);

    for (i = 0; str[i] != '\0'; i++)
    {
        if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' ||
            str[i] == 'o' || str[i] == 'u' ||
            str[i] == 'A' || str[i] == 'E' || str[i] == 'I' ||
            str[i] == 'O' || str[i] == 'U')
        {
            vowels++;
        }
    }

    cout << "Number of vowels: " << vowels << endl;
    return 0;
}

Notice the loop condition: str[i] != '\0'. This is the standard way to iterate through a C-style string — you keep going until you hit the null terminator. You do NOT need to know the length beforehand. The '\0' acts as the stop sign. This is why the null terminator is so important — without it, the loop would keep reading into garbage memory!

Worked Example 9: Check if a String is a Palindrome

#include <iostream>
#include <cstring>
using namespace std;

int main()
{
    char str[50];
    int len, i, isPalindrome = 1;

    cout << "Enter a string: ";
    cin >> str;

    len = strlen(str);

    for (i = 0; i < len / 2; i++)
    {
        if (str[i] != str[len - 1 - i])
        {
            isPalindrome = 0;
            break;
        }
    }

    if (isPalindrome)
        cout << "Palindrome!" << endl;
    else
        cout << "Not a palindrome." << endl;

    return 0;
}

A palindrome reads the same forward and backward (like “madam” or “racecar”). The logic: compare the first character with the last, the second with the second-last, and so on. We only need to check up to the middle (len / 2). If any pair does not match, it is not a palindrome.

Chapter Summary — Key Points to Remember

Quick Revision Notes — Exam Focus

Challenge Exam Questions — Test Yourself!

int arr[] = {5, 10, 15, 20, 25};
int s = 0;
for (int i = 1; i < 4; i++)
    s += arr[i];
cout << s;

int arr[5] = {1, 2, 3, 4, 5};
arr[0] = arr[0] + arr[4];
arr[4] = arr[1] + arr[3];
arr[2] = arr[0] - arr[4];

char str[] = "programming";
int count = 0;
for (int i = 0; str[i] != '\0'; i++)
{
    if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' ||
        str[i] == 'o' || str[i] == 'u')
        count++;
}
cout << count;

char s1[20] = "Good";
char s2[] = "Morning";
char result[20];
strcpy(result, s1);
strcat(result, " ");
strcat(result, s2);

#include <iostream>
using namespace std;

int main()
{
    int arr[6] = {34, 89, 12, 89, 67, 45};
    int n = 6;
    int largest = arr[0], secondLargest = -99999;

    for (int i = 1; i < n; i++)
    {
        if (arr[i] > largest)
        {
            secondLargest = largest;
            largest = arr[i];
        }
        else if (arr[i] > secondLargest && arr[i] != largest)
        {
            secondLargest = arr[i];
        }
    }

    if (secondLargest == -99999)
        cout << "No second largest element." << endl;
    else
        cout << "Second largest: " << secondLargest << endl;

    return 0;
}
// Output: Second largest: 67

int arr[5] = {10, 20, 30, 40, 50};
int i;
for (i = 0; i < 5; i++)
    cout << arr[i] * 2 << " ";
cout << endl << arr[2];

#include <iostream>
using namespace std;

int main()
{
    int matrix[3][3];
    int i, j, rowSum;

    cout << "Enter 9 elements for 3x3 matrix:" << endl;
    for (i = 0; i < 3; i++)
        for (j = 0; j < 3; j++)
            cin >> matrix[i][j];

    cout << "\nRow sums:" << endl;
    for (i = 0; i < 3; i++)
    {
        rowSum = 0;
        for (j = 0; j < 3; j++)
        {
            rowSum += matrix[i][j];
        }
        cout << "Row " << (i + 1) << " sum = " << rowSum << endl;
    }

    return 0;
}

char s1[] = "abc";
char s2[] = "abd";
cout << strcmp(s1, s2);

#include <iostream>
using namespace std;

int main()
{
    char source[] = "Hello World";
    char dest[20];
    int i;

    for (i = 0; source[i] != '\0'; i++)
    {
        dest[i] = source[i];
    }
    dest[i] = '\0';  // Manually add null terminator!

    cout << "Source: " << source << endl;
    cout << "Destination: " << dest << endl;

    return 0;
}

int a[3] = {1, 2, 3};
int b[3];
b = a;
cout << b[0];

int arr[4] = {5, 10, 15, 20};
int *p = arr;
cout << *(p + 2);

#include <iostream>
#include <cstring>
using namespace std;

int main()
{
    char str[50], temp;
    int len, i, j;

    cout << "Enter a string: ";
    cin >> str;

    len = strlen(str);

    for (i = 0, j = len - 1; i < j; i++, j--)
    {
        temp = str[i];
        str[i] = str[j];
        str[j] = temp;
    }

    cout << "Reversed: " << str << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int a[] = {1, 3, 5, 7, 9};
    int b[] = {2, 4, 6, 8, 10};
    int c[10];
    int n1 = 5, n2 = 5;
    int i = 0, j = 0, k = 0;

    while (i < n1 && j < n2)
    {
        if (a[i] < b[j])
            c[k++] = a[i++];
        else
            c[k++] = b[j++];
    }

    // Copy remaining elements from a
    while (i < n1)
        c[k++] = a[i++];

    // Copy remaining elements from b
    while (j < n2)
        c[k++] = b[j++];

    cout << "Merged sorted array:" << endl;
    for (int m = 0; m < 10; m++)
        cout << c[m] << " ";

    return 0;
}
// Output: 1 2 3 4 5 6 7 8 9 10

int arr[5] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; i++)
    arr[i] = arr[5 - 1 - i];
for (int i = 0; i < 5; i++)
    cout << arr[i] << " ";