Basic C+ Programming Exercises for Beginners: 50+ Coding Problems with Solutions

#include <iostream>

int main() {
    int num1, num2;

    std::cout << "Enter the first integer: "<< std::endl;
    std::cin >> num1;
    std::cout << "Enter the second integer: "<< std::endl;
    std::cin >> num2;

    // Perform and display arithmetic operations
    std::cout << "\nResults:" << std::endl;
    std::cout << "Sum: " << num1 + num2 << std::endl;
    std::cout << "Difference: " << num1 - num2 << std::endl;
    std::cout << "Product: " << num1 * num2 << std::endl;
    
    // Check to prevent division by zero
    if (num2 != 0) {
        std::cout << "Quotient (Integer Division): " << num1 / num2 << std::endl;
    } else {
        std::cout << "Cannot calculate Quotient: Division by zero!" << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program takes two integer inputs, num1 and num2 using the std::cin object along with the extraction operator >> to read the values.
• It then uses the respective operators directly within the std::cout statements to perform the calculations.
• The division operation / is specifically handled with an if statement to check if the second number is zero, preventing a runtime error (division by zero).

#include <iostream>

int main() {
    double length, width, area;

    std::cout << "Enter the length of the rectangle: "<< std::endl;
    std::cin >> length;

    std::cout << "Enter the width of the rectangle: "<< std::endl;
    std::cin >> width;

    // Calculate the area
    area = length * width;

    // Display the result
    std::cout << "The area of the rectangle is: " << area << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Three variables of type double are used to handle potential decimal values for the dimensions and the area.
• The program reads the input for length and width. The core calculation is straightforward multiplication.
• Storing the result in the area variable before printing is good practice, though not strictly required in this simple case.

#include <iostream>

int main() {
    double num1 =4.5, num2=5.5, num3=6.5;
    double average;

    // Calculate the average (sum divided by 3.0 to ensure float division)
    average = (num1 + num2 + num3) / 3.0; 

    std::cout << "The average of the three numbers is: " << average << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• By declaring num1, num2, and num3 as double, any input, including integers, is stored as a floating-point number.
• The expression (num1 + num2 + num3) / 3.0 uses the literal 3.0 (a double) to force the entire division to be a floating-point operation, which ensures the resulting average variable holds the accurate decimal value.

#include <iostream>

int main() {
    // Use the sizeof operator on fundamental data types
    std::cout << "Size of char: " << sizeof(char) << " byte(s)" << std::endl;
    std::cout << "Size of int: " << sizeof(int) << " byte(s)" << std::endl;
    std::cout << "Size of float: " << sizeof(float) << " byte(s)" << std::endl;
    std::cout << "Size of double: " << sizeof(double) << " byte(s)" << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The sizeof operator is a compile-time operator that returns the size of its operand in memory, measured in bytes.
• This program illustrates how the size of standard data types can vary between different architectures and compilers, though char is guaranteed to be 1 byte, and int is typically 4 bytes on most modern systems

#include <iostream>

int main() {
    char ch;

    std::cout << "Enter a single character: "<< std::endl;
    std::cin >> ch;

    // Cast the char to an int to print its ASCII value
    int asciiValue = (int)ch;

    std::cout << "The ASCII value of '" << ch << "' is: " << asciiValue << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The character is stored in the char ch variable.
• When we assign (int)ch to asciiValue, we are performing an explicit type conversion or casting.
• This tells the compiler to treat the character’s memory content not as a character symbol but as its underlying integer value, which is the ASCII code.

#include <iostream>

int main() {
    int A = 10, B = 20;
    int temp; // The necessary temporary variable
    std::cout << "\nBefore swap: A = " << A << ", B = " << B << std::endl;

    // Step 1: Store A's value in temp
    temp = A; 
    // Step 2: Assign B's value to A
    A = B; 
    // Step 3: Assign temp's value (original A) to B
    B = temp; 

    std::cout << "After swap: A = " << A << ", B = " << B << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This is the standard and safest method for swapping values.
• The temporary variable, temp, acts as a placeholder to prevent the original value of A from being overwritten and lost when B‘s value is assigned to A in the second step.

#include <iostream>

int main() {
    int A = 10, B = 20;

    std::cout << "Before swap: A = " << A << ", B = " << B << std::endl;

    // Arithmetic Swap Logic
    A = A + B; // A = (Original A + Original B)
    B = A - B; // B = (Original A + Original B) - Original B = Original A
    A = A - B; // A = (Original A + Original B) - Original A = Original B

    std::cout << "After swap: A = " << A << ", B = " << B << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This method uses arithmetic properties to achieve the swap.
• In the second step, the subtraction effectively isolates the original value of A and stores it in B.
• In the third step, the subtraction isolates the original value of B and stores it in A.
• Note: This technique can sometimes cause overflow errors if the sum exceeds the capacity of the integer type.

#include <iostream>

int main() {
    double principal = 1000, rate = 10, time = 3, simpleInterest;

    // Formula: SI = (P * R * T) / 100
    simpleInterest = (principal * rate * time) / 100.0; 

    std::cout << "\nSimple Interest (SI) is: " << simpleInterest << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• All variables are declared as double for precision.
• The input is taken for Principal, Rate, and Time.
• The calculation implements the standard Simple Interest formula. Dividing by 100.0 (a floating-point literal) ensures that the division operation is a floating-point division, correctly handling decimal results for the interest.

#include <iostream>

int main() {
    int number = 10;

    // Use the modulo operator to check for even/odd
    if (number % 2 == 0) {
        std::cout << number << " is an EVEN number." << std::endl;
    } else {
        std::cout << number << " is an ODD number." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The if condition checks number % 2 == 0. The modulo operator (%) calculates the remainder. If the remainder is 0, the number is perfectly divisible by 2, and the code inside the if block executes, declaring the number as even.
• If the remainder is anything else (for integers, it must be 1), the code inside the else block executes, declaring it as odd.

#include <iostream>

int main() {
    int a = 10, b = 40, c = 30;

    if (a >= b && a >= c) {
        std::cout << a << " is the largest number." << std::endl;
    } else if (b >= a && b >= c) {
        std::cout << b << " is the largest number." << std::endl;
    } else {
        // If A and B are not the largest, C must be the largest (or equal to one of the others)
        std::cout << c << " is the largest number." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The logical AND operator (&&) is used to check two conditions simultaneously.
• The first if checks if a is greater than or equal to both b and c. If true, a is the largest.
• If false, the else if checks the same for b. If both checks fail, the last else block correctly identifies c as the largest.
• Using >= handles cases where two or all three numbers are equal.

#include <iostream>

int main() {
    int year = 2024;

    // Leap year condition: (Divisible by 4 AND NOT divisible by 100) OR (Divisible by 400)
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
        std::cout << year << " is a Leap Year." << std::endl;
    } else {
        std::cout << year << " is NOT a Leap Year." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This solution translates the complex rule into a single, efficient boolean expression.
• The parentheses enforce the correct order of operations.
• The first part (year % 4 == 0 && year % 100 != 0) covers most leap years.
• The second part (year % 400 == 0) handles the century exceptions.
• The || (OR) ensures that if either part is true, the year is a leap year.

#include <iostream>

int main() {
    double num1, num2, result;
    char op;

    std::cout << "Enter first number: "<< std::endl;
    std::cin >> num1;
    std::cout << "Enter operator (+, -, *, /): "<< std::endl;
    std::cin >> op;
    std::cout << "Enter second number: "<< std::endl;
    std::cin >> num2;

    switch (op) {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num1 - num2;
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            if (num2 != 0) {
                result = num1 / num2;
            } else {
                std::cout << "Error! Division by zero is not allowed." << std::endl;
                return 1; // Indicate error
            }
            break;
        default:
            std::cout << "Error! Invalid operator entered." << std::endl;
            return 1;
    }

    std::cout << num1 << " " << op << " " << num2 << " = " << result << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The switch statement is excellent for handling a single variable that can have many discrete values (the operator).
• Each case label matches one possible operator.
• The division case includes an inner if statement to safely check for and prevent division by zero.
• The default case handles any operator not defined in the other cases.

#include <iostream>

int main() {
    int score;

    std::cout << "Enter the student's score (0-100): "<< std::endl;
    std::cin >> score;

    if (score < 0 || score > 100) {
        std::cout << "Invalid score entered." << std::endl;
    } else if (score >= 90) {
        std::cout << "Grade: A" << std::endl;
    } else if (score >= 80) {
        std::cout << "Grade: B" << std::endl;
    } else if (score >= 70) {
        std::cout << "Grade: C" << std::endl;
    } else if (score >= 60) {
        std::cout << "Grade: D" << std::endl;
    } else {
        std::cout << "Grade: F" << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This uses a classic if-else if ladder. The conditions are ordered from highest to lowest score.
• Since conditions are checked sequentially, if the code reaches else if (score >= 80), it means the previous check (score >= 90) was false, guaranteeing the score is between 80 and 89.
• The initial if is a good way to handle unexpected input.

#include <iostream>

int main() {
    double sideA = 10, sideB = 10, sideC = 8;

    // First check: Is it a valid triangle?
    if (sideA + sideB <= sideC || sideA + sideC <= sideB || sideB + sideC <= sideA) {
        std::cout << "The given sides DO NOT form a valid triangle." << std::endl;
    } else if (sideA == sideB && sideB == sideC) {
        std::cout << "The triangle is Equilateral." << std::endl;
    } else if (sideA == sideB || sideA == sideC || sideB == sideC) {
        std::cout << "The triangle is Isosceles." << std::endl;
    } else {
        std::cout << "The triangle is Scalene." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The main type checking then begins: Equilateral is checked first (three equalities).
• If that is false, Isosceles is checked (any two equalities using ||).
• If neither of the equality conditions is met, the triangle must be Scalene, which is caught by the final else.

#include <iostream>

int main() {
    int N = 10;
    int sum = 0;

    // Loop from 1 up to N (inclusive)
    for (int i = 1; i <= N; ++i) {
        sum = sum + i; // Add the current number to the running sum
    }

    std::cout << "The sum of natural numbers up to " << N << " is: " << sum << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

The for loop is ideal here because the number of iterations (N) is known in advance.

• The loop control variable i starts at 1. In each cycle, the value of i is added to sum.
• The loop stops once i exceeds N, and the final calculated sum is printed.

#include <iostream>

int main() {
    int N = 3;
    std::cout << "\nMultiplication Table for " << N << ":" << std::endl;

    // Loop 10 times, where i represents the multiplier (1 to 10)
    for (int i = 1; i <= 10; ++i) {
        int product = N * i;
        // Output in the format: N x i = product
        std::cout << N << " x " << i << " = " << product << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The for loop iterates 10 times, representing the multipliers 1 through 10.
• In each iteration, the product is calculated using N *i and printed immediately.

#include <iostream>

int main() {
    int N = 5;
    // Use long long for the result to handle larger factorials
    long long factorial = 1; 

    if (N < 0) {
        std::cout << "Factorial is not defined for negative numbers." << std::endl;
    } else if (N == 0) {
        std::cout << "Factorial of 0 is 1." << std::endl;
    } else {
        // Loop from N down to 1
        for (int i = N; i >= 1; --i) {
            factorial *= i; // Equivalent to: factorial = factorial * i;
        }
        std::cout << "Factorial of " << N << " is: " << factorial << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program first handles edge cases (N < 0 and N = 0).
• For positive N, the for loop runs in reverse order from N down to 1.
• The factorial variable is repeatedly multiplied by the loop counter i in an accumulation process, resulting in the final factorial value.

#include <iostream>

int main() {
    int N = 8;
    long long a = 0, b = 1; // Start of the series
    long long nextTerm;

    std::cout << "Fibonacci Series: "<<std::endl;

    if (N >= 1) {
        std::cout << a;
    }
    if (N >= 2) {
        std::cout << ", " << b;
    }

    // Loop starts at i=3 since the first two terms are printed already
    for (int i = 3; i <= N; ++i) {
        nextTerm = a + b;
        std::cout << ", " << nextTerm;
        
        // Update a and b for the next iteration
        a = b;
        b = nextTerm;
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program handles the first two terms (0 and 1) outside the loop.
• The for loop then calculates and prints the remaining terms. The key logic is the variable reassignment: a takes the value of the old b, and b takes the value of the new nextTerm.
• This effectively shifts the “window” of the previous two numbers forward by one step in the sequence.

#include <iostream>

int main() {
    int number = 12345, reversed = 0;

    int originalNumber = number;

    // Loop until the number becomes 0
    while (number > 0) {
        int digit = number % 10;       // 1. Get the last digit
        reversed = (reversed * 10) + digit; // 2. Add the digit to the reversed number
        number /= 10;                 // 3. Remove the last digit (integer division)
    }

    std::cout << "The reverse of " << originalNumber << " is: " << reversed << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

The while loop is used because the number of iterations is unknown (it depends on the number of digits). In each iteration:

1. Remove the last digit from the original number using integer division: number = number / 10.
2. Extract the last digit using the modulo operator: digit = number % 10.
3. Build the reversed number: reversed = (reversed * 10) + digit.

Note: Integer division /= 10 truncates the last digit, bringing the loop closer to termination.

#include <iostream>

int main() {
    long long N = 4829;
    int count = 0;

    long long originalN = N;

    if (N == 0) {
        count = 1; // Special case: the number 0 has one digit
    } else {
        // Loop until the number becomes 0
        while (N > 0) {
            N /= 10; // Remove the last digit
            count++; // Increment the counter
        }
    }

    std::cout << "The number of digits in " << originalN << " is: " << count << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This uses a while loop for counting iterations.
• In each iteration, simply increment a counter variable and divide the number by 10 (integer division) to “remove” one digit.
• By repeatedly dividing N by 10 and incrementing count, we essentially count how many times we can remove a digit before the number becomes zero or less than zero.
• A separate check is included for the input N=0, which is a single digit.

#include <iostream>

int main() {
    int N = 4;    

    // Outer loop controls the rows
    for (int i = 1; i <= N; ++i) {
        // Inner loop controls the columns (prints the stars in the current row)
        for (int j = 1; j <= N; ++j) {
            std::cout << "* ";
        }
        std::cout << std::endl; // Move to the next line after the row is complete
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise introduces nested loops.
• The outer loop iterates N times for the N rows. For every row, the inner loop iterates N times, printing one * for each column.
• The crucial std::endl after the inner loop ensures that each subsequent row starts on a new line, forming the square pattern.

#include <iostream>

int main() {
    int N = 4;

    // Outer loop controls the rows (i)
    for (int i = 1; i <= N; ++i) {
        // Inner loop controls the columns (j). It prints i stars.
        for (int j = 1; j <= i; ++j) {
            std::cout << "* ";
        }
        std::cout << std::endl; // Move to the next line
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The outer loop variable i represents the current row number.
• By setting the inner loop’s termination condition to j <= i, the inner loop prints exactly i asterisks for the i-th row.
• This dynamic condition creates the triangular shape, as the number of stars increases by one in each subsequent row.

#include <iostream>
#include <algorithm> // Needed for std::min (optional, can use if/else)

int main() {
    int A = 50, B = 15;
    int gcd = 1;

    // Determine the minimum of A and B
    int minimum = std::min(A, B); 

    // Loop from 1 up to the minimum number
    for (int i = 1; i <= minimum; ++i) {
        // Check if i divides both A and B evenly
        if (A % i == 0 && B % i == 0) {
            gcd = i; // Store the largest common divisor found so far
        }
    }

    std::cout << "The GCD of " << A << " and " << B << " is: " << gcd << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This solution uses a for loop to check every number from 1 up to the smaller of A and B.
• The if condition uses the logical AND (&&) to ensure that the current loop counter i is a divisor of both numbers. Because the loop iterates in increasing order, the last value stored in gcd will necessarily be the greatest common divisor.

#include <iostream>
#include <vector>

int main() {
    int N;
    long long sum = 0; // Use long long for the sum

    std::cout << "Enter the number of elements (N): " << std::endl;
    std::cin >> N;

    // Use a vector for a dynamically sized array in modern C++
    std::vector<int> arr(N); 

    std::cout << "Enter " << N << " integers:" << std::endl;
    for (int i = 0; i < N; ++i) {
        std::cout << "Element " << i + 1 << ": ";
        std::cin >> arr[i];
        sum += arr[i]; // Accumulate the sum inside the input loop
    }

    std::cout << "\nThe sum of all elements in the array is: " << sum << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

The program uses a std::vector to handle the dynamically sized array based on user input N.

• A single for loop iterates from index 0 up to N-1.
• In each iteration, the number is read into arr[i], and immediately added to the sum variable.
• Using a data type like long long for the sum variable is recommended to prevent potential integer overflow.

#include <iostream>

int main() {
    const int N = 5; // Fixed size for simplicity
    int arr[5] = {10, 30, 40, 60, 20}; 

    // Assume the first element is the largest
    int max_val = arr[0]; 

    // Loop through the rest of the elements starting from index 1
    for (int i = 1; i < N; ++i) {
        if (arr[i] > max_val) {
            max_val = arr[i]; // Update max_val if current element is larger
        }
    }

    std::cout << "The largest element in the array is: " << max_val << std::endl;
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program initializes max_val with a value that is guaranteed to be in the array (arr[0]).
• The for loop then iterates through the remaining elements. The conditional check if (arr[i] > max_val) is the core logic.
• If a larger value is found, max_val is updated. This ensures that after the loop finishes, max_val holds the maximum value encountered.

#include <iostream>

int main() {
    const int N = 5;
    int arr[N] = {10, 25, 40, 15, 30}; 
    int target = 40;
    int foundIndex = -1; // -1 indicates the element has not been found

    std::cout << "Array elements are: 10, 25, 40, 15, 30" << std::endl;

    // Linear search loop
    for (int i = 0; i < N; ++i) {
        if (arr[i] == target) {
            foundIndex = i; // Store the index
            break;          // Stop searching immediately
        }
    }

    if (foundIndex != -1) {
        std::cout << "Element " << target << " found at index: " << foundIndex << std::endl;
    } else {
        std::cout << "\nElement " << target << " was not found in the array." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This implements a linear search algorithm. The loop iterates through the array sequentially.
• The moment arr[i] matches the target, the index i is recorded, and break ensures the program exits the loop instantly.
• The final check on foundIndex determines whether a successful match was ever recorded.

#include <iostream>

int main() {
    int arr[] = {1, 3, 2, 3, 4, 3, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 3;
    int count = 0; // Initialize counter

    // Iterate through the array elements
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            count++; // Increment the counter when the target is found
        }
    }

    std::cout << "The number " << target << " occurs " << count << " times." << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This is another variation of the traversal pattern where an operation (incrementing a counter) is conditionally applied.

The count variable tallies the total number of times the target value (3) is found. Unlike the Linear Search, the for loop must continue until the end of the array to ensure every instance of the target is counted.

#include <iostream>

// Helper function to print the array contents
void printArray(const int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << (i < size - 1 ? ", " : "");
    }
    std::cout << std::endl;
}

int main() {
    const int N = 6;
    int arr[N] = {10, 20, 30, 40, 50, 60}; 

    std::cout << "Original Array: ";
    printArray(arr, N);

    // Swap elements from opposite ends of the array, iterating only halfway
    for (int i = 0; i < N / 2; ++i) {
        int temp = arr[i];         // 1. Store the front element
        arr[i] = arr[N - 1 - i];   // 2. Overwrite front with back element
        arr[N - 1 - i] = temp;     // 3. Overwrite back with original front (temp)
    }

    std::cout << "Reversed Array: ";
    printArray(arr, N);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The solution performs an in-place reversal by iterating only up to half the array size (N / 2).
• The key calculation N - 1 - i provides the index symmetrical to i from the end of the array.
• The three-step swap process (using temp) is essential to prevent data loss when overwriting the first value.

#include <iostream>

int main() {
    int arr[] = {1, 6, 3, 8, 5, 10, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    std::cout << "The even numbers in the array are: "<< std::endl;

    // Iterate through the array
    for (int i = 0; i < size; ++i) {
        // Check if the number is perfectly divisible by 2
        if (arr[i] % 2 == 0) {
            std::cout << arr[i] << " ";
        }
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise introduces the concept of conditional printing during array traversal.

• The modulus operator (%) is used to find the remainder of a division. If the remainder of dividing an element by 2 is 0 (arr[i] % 2 == 0), the number is an even number, and the program executes the printing action.
• Otherwise, the number is skipped, effectively filtering the output to only show even values.

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int size = sizeof(arr) / sizeof(arr[0]);

    std::cout << "Array BEFORE swap: "<< std::endl;
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // Perform the swap
    int temp = arr[0];         // Step 1: Store the first element
    arr[0] = arr[size - 1];    // Step 2: Overwrite the first element with the last
    arr[size - 1] = temp;      // Step 3: Overwrite the last element with the stored first element

    std::cout << "Array AFTER swap: "<< std::endl;
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise teaches the standard variable swap technique, which is crucial for sorting algorithms and in-place array modifications.

Without the temporary variable (temp), the value of the first element would be lost when the second step is executed, as it would be immediately overwritten by the value of the last element. The temporary variable preserves the data during the three-step exchange.

#include <iostream>

int main() {
    int arr[] = {1, 0, 5, 0, 8, 0, 2};
    int size = sizeof(arr) / sizeof(arr[0]);

    std::cout << "Original array: ";
    for (int x : arr) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    // Loop to modify the array
    for (int i = 0; i < size; ++i) {
        if (arr[i] == 0) {
            arr[i] = -1; // Replace 0 with -1
        }
    }

    std::cout << "Modified array: ";
    for (int x : arr) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise demonstrates in-place modification of an array.

The for loop iterates through the entire array. if the element meets the criteria (arr[i] == 0), its value is changed directly within the array’s memory location (arr[i] = -1). This process alters the array permanently for subsequent operations.

#include <iostream>

// Recursive function definition
long long factorial(int n) {
    // Base Case: stops the recursion
    if (n == 0) {
        return 1;
    }
    // Recursive Step: calls itself with a smaller input
    return n * factorial(n - 1);
}

int main() {
    int number = 5;
    long long result = factorial(number);
    
    std::cout << number << "! is: " << result << std::endl; // Output: 120
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• This is a classic example of Recursion, where a function calls itself.
• Every recursive function must have a base case (if (n == 0)) to prevent infinite calls, and a recursive step (n * factorial(n - 1)) that moves the input closer to the base case.
• The function breaks the problem (finding 5!) into a smaller problem (finding 4!) until it reaches the solvable base case (0!).

#include <iostream>
#include <string>

int main() {
    std::string inputStr; 
    int length = 0;

    std::cout << "Enter a string (may include spaces): "<< std::endl;
    // std::getline is used to read the whole line including spaces
    std::getline(std::cin, inputStr); 

    // Manual length calculation loop
    for (int i = 0; ; ++i) {
        // Check if we reached the null terminator (for conceptual/C-style consistency)
        // In std::string, accessing past the length() might be dangerous,
        // but we assume standard string termination for this exercise.
        if (inputStr[i] == '\0' || i >= inputStr.length()) {
            break;
        }
        length++;
    }

    // A simpler, more compliant way to meet the spirit of the exercise:
    // length = 0;
    // for (char c : inputStr) {
    //     length++;
    // }

    std::cout << "The length of the string (manually counted) is: " << length << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This solution uses a for loop that iterates until it detects the end of the string.
• While a C-style string uses \0 as a sentinel, the std::string version relies on the bounds or the conceptual end.
• By checking inputStr[i] != '\0' (the sentinel) and incrementing the counter, the loop effectively counts the characters one by one, achieving the goal without calling length().

#include <iostream>
#include <string>

int main() {
    std::string str = "level";
    bool isPalindrome = true;

    int length = str.length();
    int i = 0;             // Start index
    int j = length - 1;    // End index

    // Check characters symmetrically from the outside in
    while (i < j) {
        if (str[i] != str[j]) {
            isPalindrome = false;
            break; // Mismatch found, stop checking
        }
        i++; // Move inward from the left
        j--; // Move inward from the right
    }

    if (isPalindrome) {
        std::cout << "'" << str << "' IS a palindrome." << std::endl;
    } else {
        std::cout << "'" << str << "' is NOT a palindrome." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The two-pointer approach one at the start (i = 0) and one at the end (j = length - 1) efficiently checks for the palindrome property by comparing characters symmetrically.
• The while (i < j) condition ensures the loop runs until the pointers meet or cross, covering exactly half the string comparisons.
• If the loop completes without setting isPalindrome to false, the string is confirmed to be a palindrome.

#include <iostream>
#include <string>
#include <cctype> // Required for tolower() and isalpha()

int main() {
    std::string str = "PYnative";
    int vowelCount = 0;
    int consonantCount = 0;

    // Iterate through each character in the string
    for (char ch : str) {
        // 1. Convert to lowercase for simplified comparison
        ch = std::tolower(ch); 

        // 2. Check if the character is a letter of the alphabet
        if (std::isalpha(ch)) {
            // 3. Check if the letter is a vowel
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
                vowelCount++;
            } else {
                // If it's a letter but not a vowel, it's a consonant
                consonantCount++;
            }
        }
    }

    std::cout << "Vowel Count: " << vowelCount << std::endl;
    std::cout << "Consonant Count: " << consonantCount << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The use of std::isalpha() ensures that only valid letters are processed, ignoring other symbols.
• Converting the character to lowercase with std::tolower() simplifies the vowel check, as only the five lowercase letters need to be tested.
• The program correctly partitions the letters into the vowelCount and consonantCount variables.

#include <iostream>
#include <string>

int main() {
    std::string main_string = "PYnative c++ Exercises";
    std::string sub_string = "c++";

    // Use the find() method
    size_t found_index = main_string.find(sub_string);

    if (found_index != std::string::npos) {
        std::cout << "Substring found!" << std::endl;
        std::cout << "Starting index: " << found_index << std::endl;
    } else {
        std::cout << "Substring not found in the main text." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise is efficiently solved using the built-in std::string::find() method.
• The method returns a size_t value, which is an unsigned integer type used for sizes and indices. If the substring is found, found_index holds the index.
• If it is not found, found_index holds the static constant std::string::npos. The if statement checks for this condition to determine the output.

#include <iostream>
#include <string>
#include <map> // Required for std::map
#include <cctype>

int main() {
    std::string str = "Programming in CPP";
    std::map<char, int> char_counts;

    std::cout << "Analyzing string: " << str << std::endl;

    // 1. Iterate through the string and populate the map
    for (char c : str) {
        if (std::isalpha(c)) {
            // Convert to lowercase and use as the map key
            char_counts[std::tolower(c)]++;
        }
    }

    // 2. Iterate through the map and print the results
    std::cout << "Character Frequencies:" << std::endl;
    for (const auto& pair : char_counts) {
        std::cout << "'" << pair.first << "': " << pair.second << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The std::map<char, int> container is used to store the frequency. The loop processes the input string character by character.
• If a character is a letter (std::isalpha), it’s converted to lowercase (std::tolower) to ensure case-insensitivity (e.g., ‘A’ and ‘a’ count together).
• When a character is used as an index into the map (e.g., char_counts['a']++), if the key doesn’t exist, the map automatically inserts it with a default value of 0 before incrementing, making the counting process very concise.

#include <iostream>

int main() {
    const int ROWS = 2;
    const int COLS = 2;
    int A[ROWS][COLS], B[ROWS][COLS], C[ROWS][COLS];

    // 1. Read Matrix A
    std::cout << "Enter elements for Matrix A (2x2):" << std::endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            std::cout << "A[" << i << "][" << j << "]: ";
            std::cin >> A[i][j];
        }
    }

    // 2. Read Matrix B
    std::cout << "Enter elements for Matrix B (2x2):" << std::endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            std::cout << "B[" << i << "][" << j << "]: ";
            std::cin >> B[i][j];
        }
    }

    // 3. Calculate and Print Matrix C (A + B)
    std::cout << "\nResulting Matrix C (A + B):" << std::endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            C[i][j] = A[i][j] + B[i][j];
            std::cout << C[i][j] << "\t"; // Use tab for neat alignment
        }
        std::cout << std::endl; // Newline after each row is complete
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates handling multi-dimensional arrays using nested loops.
• The outer loop controls the row index (i), and the inner loop controls the column index (j).
• Matrix addition requires adding corresponding elements, which is performed by the simple element-wise summation C[i][j] = A[i][j] + B[i][j] within the final set of nested loops.

#include <iostream>
#include <cmath> // Needed for sqrt()

int main() {
    int N = 23;
    bool isPrime = true;

    if (N <= 1) {
        isPrime = false;
    } else {
        // Only need to check divisors up to the square root of N
        for (int i = 2; i <= sqrt(N); ++i) {
            if (N % i == 0) {
                isPrime = false; // Found a divisor, not prime
                break; // Optimization: exit the loop immediately
            }
        }
    }

    if (isPrime) {
        std::cout << N << " is a PRIME number." << std::endl;
    } else {
        std::cout << N << " is NOT a prime number." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program uses a boolean flag isPrime, initialized to true.
• The loop iterates through potential divisors. If N is divisible by any i (remainder is 0), isPrime is set to false, and break stops the loop, saving computation time.
• The use of sqrt(N) is an optimization technique because any composite number N must have at least one divisor less than or equal to its square root.

#include <iostream>

const double PI = 3.14159;

// 1. Overloaded function for Circle Area (one double argument)
double calculateArea(double radius) {
    return PI * radius * radius;
}

// 2. Overloaded function for Rectangle Area (two double arguments)
double calculateArea(double length, double width) {
    return length * width;
}

int main() {
    // Call the circle area function (Compiler chooses based on one double argument)
    std::cout << "Area of Circle (Radius 5.0) = " << calculateArea(5.0) << std::endl; 

    // Call the rectangle area function (Compiler chooses based on two double arguments)
    std::cout << "Area of Rectangle (8.0 x 4.0) = " << calculateArea(8.0, 4.0) << std::endl; 

    return 0;
}Code language: C++ (cpp)

Explanation:

• Function overloading allows a single function name (calculateArea) to perform different tasks based on the signature (the number and type of arguments).
• The compiler determines which version of the function to execute at compile time based on the arguments provided in the function call. This enhances code clarity by using a common name for related operations.

#include <iostream>

int main() {
    int value = 100;
    int* ptr;

    // 1. Assign the address of 'value' to 'ptr'
    ptr = &value;

    // 2. Print the value using the pointer and dereference operator
    std::cout << "The value is: " << *ptr << std::endl; 

    return 0;
}Code language: C++ (cpp)

Explanation:

• The line int* ptr; declares a pointer variable named ptr that is designed to hold the memory address of an integer.
• The line ptr = &value; uses the address-of operator (&) to load the actual memory address of value into the pointer ptr.
• Finally, *ptr is the dereference operation, which follows the pointer’s address to retrieve the data (the integer 100) stored at that location.

#include <iostream>

// Function definition using pass by reference (&)
void swapValues(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
    // Changes to a and b directly affect the variables passed from main
}

int main() {
    int x = 100;
    int y = 200;

    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;

    // Call the function, passing the variables by reference
    swapValues(x, y); 

    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Pass by reference (&) is used here to avoid copying the large variables (though integers are small, the principle holds).
• When swapValues is called, the variables a and b inside the function become aliases for the variables x and y in main().
• Any modification to a or b directly changes the original variables, allowing the function to successfully swap the values outside its own scope.

#include <iostream>

int main() {
    int* safe_ptr = nullptr;

    if (safe_ptr == nullptr) {
        std::cout << "Pointer is null, cannot dereference." << std::endl;
        
        // Safely assign a valid address for the second check
        int valid_data = 77;
        safe_ptr = &valid_data;
    } 

    // Now, we can safely check again and dereference if assigned
    if (safe_ptr != nullptr) {
        std::cout << "Pointer is now valid. Dereferenced value: " << *safe_ptr << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The initialization int* safe_ptr = nullptr; explicitly sets the pointer to a known, invalid state. The first if statement checks this state using safe_ptr == nullptr.
• This is a crucial safety check to prevent crashes. The second part demonstrates assigning a valid address (&valid_data) and then safely using the pointer only after verifying it’s no longer null.

#include <iostream>

int main() {
    int x = 42;
    int* p1 = &x;       // p1 points to x
    int** p2 = &p1;     // p2 points to p1

    // Access the value of x using the double pointer p2
    std::cout << "The value accessed via double pointer is: " << **p2 << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The pointer p1 holds the address of x. The double pointer p2 holds the address of p1.
• The expression *p2 dereferences p2, which results in the content of p1 (the address of x).
• The expression **p2 then dereferences this result (the address of x), which finally gives us the integer value 42 stored in x.
• This structure is used in more complex data structures or when implementing pass-by-reference for pointers.

#include <iostream>
#include <string>
#include <limits>

// Structure definition
struct Student {
    std::string name;
    int rollNumber;
    double marks;
};

// Function 1: Pass by reference to modify the original structure
void readStudentData(Student &s) {
    std::cout << "Enter student name: ";
    // Use cin.ignore() to clear potential newline character from previous inputs
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    std::getline(std::cin, s.name); 

    std::cout << "Enter roll number: ";
    std::cin >> s.rollNumber;

    std::cout << "Enter marks: ";
    std::cin >> s.marks;
}

// Function 2: Pass by constant reference for efficiency and safety
void printStudentData(const Student &s) {
    std::cout << "\n--- Student Record ---" << std::endl;
    std::cout << "Name: " << s.name << std::endl;
    std::cout << "Roll Number: " << s.rollNumber << std::endl;
    std::cout << "Marks: " << s.marks << std::endl;
}

int main() {
    Student s1;
    
    readStudentData(s1);
    printStudentData(s1);

    return 0;
}Code language: C++ (cpp)

Explanation:

• By passing the structure by reference (Student &s), the readStudentData function can modify the s1 variable in main() without creating a copy.
• Passing by constant reference (const Student &s) in printStudentData ensures that the function is efficient (no copy) and read-only (guaranteed by const).

#include <iostream>

int main() {
    int value = 42;
    int *ptr; // Declare an integer pointer

    // Store the address of 'value' into 'ptr'
    ptr = &value; 

    std::cout << "1. Value of the variable 'value': " << value << std::endl;
    std::cout << "2. Memory address of 'value' (&value): " << &value << std::endl;
    std::cout << "3. Address stored in pointer 'ptr': " << ptr << std::endl;
    std::cout << "4. Value pointed to by 'ptr' (*ptr): " << *ptr << std::endl;
    
    // Demonstrate dereference operation modifies the original value
    *ptr = 99;
    std::cout << "\nNew value of 'value' after *ptr = 99: " << value << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise introduces pointers, which are variables that store memory addresses. The address-of operator (&) retrieves the address.
• The dereference operator (*) accesses the data stored at the address pointed to by the pointer.
• The output shows that &value and ptr hold the same memory address, and value and *ptr hold the same data value.

#include <iostream>

int main() {
    int arr[3] = {10, 20, 30};
    int *ptr = arr; // Pointer points to the first element (arr[0])

    // 1. First element
    std::cout << "--- Initial State (arr[0]) ---" << std::endl;
    std::cout << "Value: " << *ptr << " (arr[0])" << std::endl;
    std::cout << "Address: " << ptr << std::endl;

    // 2. Increment the pointer by 1
    ptr = ptr + 1; 

    // 3. Second element (after arithmetic)
    std::cout << "\n--- After ptr = ptr + 1 (arr[1]) ---" << std::endl;
    std::cout << "Value: " << *ptr << " (arr[1])" << std::endl;
    std::cout << "Address: " << ptr << std::endl;

    // Confirmation of address jump size (for explanation)
    std::cout << "\nAddress jump size (bytes): " << sizeof(int) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Pointer arithmetic works based on the size of the data type the pointer is pointing to.
• When ptr is incremented by 1, the compiler adds sizeof(int) bytes (usually 4 bytes) to the memory address stored in ptr, causing it to correctly move from the address of arr[0] to the address of arr[1]. This is essential for iterating over arrays efficiently using pointers.

#include <iostream>
#include <string>
#include <limits>

struct Book {
    std::string title;
    std::string author;
    float price;
};

const int MAX_BOOKS = 3;

int main() {
    Book books[MAX_BOOKS];

    // Input loop
    for (int i = 0; i < MAX_BOOKS; ++i) {
        std::cout << "\n--- Enter data for Book " << i + 1 << " ---" << std::endl;

        // Clear the input buffer if necessary from previous numeric input
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

        std::cout << "Title: ";
        std::getline(std::cin, books[i].title);

        std::cout << "Author: ";
        std::getline(std::cin, books[i].author);

        std::cout << "Price: $";
        std::cin >> books[i].price;
    }

    // Output loop
    std::cout << "\n===================================" << std::endl;
    std::cout << "         ALL BOOKS INVENTORY        " << std::endl;
    std::cout << "===================================" << std::endl;

    for (int i = 0; i < MAX_BOOKS; ++i) {
        std::cout << "Book " << i + 1 << ": " << books[i].title
                  << " by " << books[i].author
                  << " ($" << books[i].price << ")" << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• An array of structures is a common way to manage collections of records.
• The books[MAX_BOOKS] declaration creates a contiguous block of memory to store 3 Book objects.
• The for loops iterate over the array, using the index i to access each individual book structure. The members are accessed via the dot operator applied to the array element, e.g., books[i].title.

#include <iostream>

// Define the Day enumeration
enum Day {
    Sunday,    // 0
    Monday,    // 1
    Tuesday,   // 2
    Wednesday, // 3
    Thursday,  // 4
    Friday,    // 5
    Saturday   // 6
};

int main() {
    // Declare a variable and assign a value
    Day today = Wednesday;

    std::cout << "The integer value of Wednesday is: ";
    // Cast the enum variable to an int to print its underlying value
    std::cout << static_cast<int>(today) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• C-style enumerations (enum) provide a set of named integer constants.
• By default, the constants are assigned values sequentially starting from 0.
• The program demonstrates declaration, assignment, and the use of static_cast<int> to explicitly retrieve and print the integer value associated with the enumerator Wednesday (which is 3).

#include <iostream>
#include <string>

class Car {
public:
    std::string make;
    std::string model;
    int year;

    // Constructor for easy initialization
    Car(std::string mk, std::string md, int yr) 
        : make(mk), model(md), year(yr) {}

    // Method demonstrating a simple action/behavior
    void start_engine() {
        std::cout << year << " " << make << " " << model << " engine started!" << std::endl;
    }
};

int main() {
    Car my_car("Toyota", "Corolla", 2020);
    
    // Demonstrate interaction with attributes and method
    std::cout << "My car is a " << my_car.year << " " << my_car.make << "." << std::endl;
    my_car.start_engine();

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise shows a basic OOP concept where an object models a real-world entity.

• The attributes (make, model, year) describe the car’s state, and the method (start_engine) describes its capability or action.
• Since the attributes are public in this case, they can be directly accessed and modified outside the class (though this is often discouraged in favor of encapsulation).

#include <iostream>

class Rectangle {
private:
    int length;
    int width;

public:
    // 1. Default Constructor (no arguments)
    Rectangle() : length(1), width(1) {
        std::cout << "Default Rectangle created (1x1)." << std::endl;
    }

    // 2. Parameterized Constructor
    Rectangle(int l, int w) : length(l), width(w) {
        std::cout << "Custom Rectangle created (" << length << "x" << width << ")." << std::endl;
    }

    int get_area() const {
        return length * width;
    }
};

int main() {
    // Uses the Parameterized Constructor
    Rectangle r1(12, 4); 
    std::cout << "R1 Area: " << r1.get_area() << std::endl;

    // Uses the Default Constructor
    Rectangle r2;
    std::cout << "R2 Area: " << r2.get_area() << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This demonstrates Constructor Overloading, a form of Static Polymorphism.
• The compiler selects the correct constructor based on the number and type of arguments provided during object creation.
• A default constructor is essential for creating objects when no initial values are specified (e.g., in arrays or STL containers).

#include <iostream>
#include <string>

class Resource {
private:
    std::string id;

public:
    // Constructor
    Resource(std::string name) : id(name) {
        std::cout << ">> Resource '" << id << "' ACQUIRED (Constructed)" << std::endl;
    }

    // Destructor
    ~Resource() {
        std::cout << "<< Resource '" << id << "' RELEASED (Destructed)" << std::endl;
    }
};

void scope_test() {
    std::cout << "\n--- Entering scope_test() ---" << std::endl;
    Resource local_res("Local A"); // Object created
    std::cout << "--- Exiting scope_test() ---" << std::endl;
    // local_res is destroyed here
}

int main() {
    std::cout << "--- Starting main() ---" << std::endl;
    Resource main_res("Main B"); // Object created

    scope_test();

    std::cout << "--- Ending main() ---" << std::endl;
    // main_res is destroyed here
    return 0;
}Code language: C++ (cpp)

Explanation:

The Destructor (~Classname) is a special member function that is automatically called when an object’s lifetime ends, which occurs when it goes out of scope (as seen in scope_test() and main()):

• Its primary purpose is cleanup. It ensures that any dynamically allocated memory or external resources (files, network connections, etc.) are properly cleaned up when the object is no longer needed.
• This is fundamental to C++’s powerful RAII (Resource Acquisition Is Initialization) paradigm, which prevents memory leaks and resource exhaustion by tying resource lifetime to object lifetime.

#include <fstream>
#include <iostream>
#include <string>

int main() {
    // 1. Declare an output file stream object
    std::ofstream outFile;

    // 2. Open the file (creates it if it doesn't exist)
    outFile.open("mydata.txt");

    // 3. Check if the file was successfully opened
    if (outFile.is_open()) {
        // 4. Write data to the file
        outFile << "Hello, File Handling!" << std::endl;
        std::cout << "Successfully wrote data to mydata.txt" << std::endl;

        // 5. Close the file stream
        outFile.close();
    } else {
        std::cerr << "Unable to open file mydata.txt" << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise introduces the file writing: std::ofstream. We declare an object, outFile, and call its open() method with the desired filename.
• The crucial step is the error check using is_open(); if this fails, the program reports an error.
• The output is written using the standard stream insertion operator <<.
• Finally, outFile.close() is called to flush any remaining buffer data and release the file handle back to the operating system.

#include <fstream>
#include <iostream>
#include <string>

int main() {
    // 1. Declare an input file stream object
    std::ifstream inFile("mydata.txt"); 
    std::string fileLine;

    // 2. Check if the file was successfully opened
    if (inFile.is_open()) {
        std::cout << "--- Content of mydata.txt ---" << std::endl;
        
        // 3. Read the file line by line
        while (std::getline(inFile, fileLine)) {
            // 4. Display the read line
            std::cout << fileLine << std::endl;
        }

        // 5. Close the file stream
        inFile.close();
    } else {
        // 6. Report error if file opening failed
        std::cerr << "Error: Unable to open file mydata.txt for reading." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The std::ifstream object, inFile, is used to read the data.

The core reading loop uses while (std::getline(inFile, fileLine)). The std::getline() function attempts to read an entire line into the fileLine string. This function returns a reference to the stream object, which evaluates to true if the read was successful and false (terminating the loop) if the end-of-file (EOF) is reached or an error occurs. This is the idiomatic way to process text files line by line in C++.

#include <fstream>
#include <iostream>

int main() {
    // 1. Declare an output file stream and open in append mode
    std::ofstream outFile("mydata.txt", std::ios::app);

    // 2. Check for successful opening
    if (outFile.is_open()) {
        // 3. Append the new line
        outFile << "This is the appended text." << std::endl;
        std::cout << "Successfully appended text to mydata.txt" << std::endl;

        // 4. Close the file stream
        outFile.close();
    } else {
        std::cerr << "Unable to open file mydata.txt for appending." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The key change here is the use of the second argument in the ofstream constructor: std::ios::app. This file mode flag modifies the behavior of the stream so that all output operations are performed at the end of the file, preserving the previous content.
• If this flag were omitted, the default behavior would be to truncate (delete) the file content and start writing from the beginning.

#include <fstream>
#include <iostream>

int main() {
    std::ifstream inFile("mydata.txt");
    char character;
    int charCount = 0;

    if (inFile.is_open()) {
        // Read character by character until the end of the file
        while (inFile.get(character)) {
            charCount++;
        }

        std::cout << "Total number of characters in mydata.txt: " << charCount << std::endl;
        inFile.close();
    } else {
        std::cerr << "Error: Unable to open file." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program uses a while loop with inFile.get(character). The get() method attempts to extract a single character (including whitespace and newline characters) and store it in the character variable.
• If the extraction is successful, the stream object evaluates to true, the loop continues, and the charCount is incremented. When the end of the file is reached or an error occurs, the stream evaluates to false, and the loop terminates.

#include <fstream>
#include <iostream>
#include <string>

int main() {
    std::ifstream inFile("mydata.txt");
    std::string line;
    int lineCount = 0;

    if (inFile.is_open()) {
        // Use getline() to read line by line
        while (std::getline(inFile, line)) {
            lineCount++;
        }

        std::cout << "Total number of lines in mydata.txt: " << lineCount << std::endl;
        inFile.close();
    } else {
        std::cerr << "Error: Unable to open file." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This solution leverages the behavior of std::getline(). Each time std::getline() successfully reads a sequence of characters up to a newline and stores it in the line string, the lineCount is incremented.
• The loop naturally terminates when the end of the file is reached. This is the most efficient and standard way to count lines in a text file using C++ streams.