16.7 — Array loops and sign challenge solutions

In this lesson, you'll tackle some common challenges that arise when working with arrays and loops, particularly focusing on signed vs unsigned integer issues. You'll learn practical solutions to these problems and develop best practices for robust array processing.

The signed/unsigned challenge recap

As we learned earlier, mixing signed and unsigned integers in array operations can lead to subtle bugs. This lesson focuses on practical solutions to these challenges.

The core problem

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    // This generates a compiler warning
    for (int i = 0; i < numbers.size(); ++i) // signed vs unsigned comparison
    {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Compiler warning:

warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type'

Solution strategies

Strategy 1: Cast to signed integer

The most straightforward solution is to cast the size to a signed type:

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    // Cast size() to int - no warning
    for (int i = 0; i < static_cast<int>(numbers.size()); ++i)
    {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }
    
    return 0;
}

Output:

numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

When to use:

• When you need the index for other purposes
• When working with smaller arrays (< 2 billion elements)
• When you need to perform arithmetic with the index

Strategy 2: Use consistent unsigned types

Keep everything unsigned to avoid mixing:

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    // Use std::size_t consistently
    for (std::size_t i = 0; i < numbers.size(); ++i)
    {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }
    
    return 0;
}

Output:

numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

When to use:

• When working with very large arrays
• When you need maximum portability
• When interfacing with APIs that use std::size_t

Strategy 3: Use range-based for loops

Avoid indices altogether when possible:

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    // No index needed - cleanest solution
    for (int value : numbers)
    {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Output:

10 20 30 40 50 

When to use:

• When you don't need the index
• For simple iteration tasks
• When readability is most important

Practical challenge solutions

Challenge 1: Safe reverse iteration

Problem: Iterate backwards through a vector without unsigned underflow:

#include <vector>
#include <iostream>

// ❌ DANGEROUS: Unsigned underflow
void dangerousReverse(const std::vector<int>& vec)
{
    // DON'T DO THIS - infinite loop risk
    // for (std::size_t i = vec.size() - 1; i >= 0; --i)
    // {
    //     std::cout << vec[i] << " ";
    // }
}

// ✅ SAFE: Using signed integer
void safeReverse_v1(const std::vector<int>& vec)
{
    for (int i = static_cast<int>(vec.size()) - 1; i >= 0; --i)
    {
        std::cout << vec[i] << " ";
    }
}

// ✅ SAFE: Using careful unsigned arithmetic
void safeReverse_v2(const std::vector<int>& vec)
{
    if (vec.empty()) return;
    
    for (std::size_t i = vec.size(); i > 0; --i)
    {
        std::cout << vec[i - 1] << " "; // Access element at index i-1
    }
}

// ✅ SAFE: Using reverse iterators
void safeReverse_v3(const std::vector<int>& vec)
{
    for (auto it = vec.rbegin(); it != vec.rend(); ++it)
    {
        std::cout << *it << " ";
    }
}

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    std::cout << "Forward: ";
    for (int num : numbers) std::cout << num << " ";
    std::cout << std::endl;
    
    std::cout << "Reverse v1: ";
    safeReverse_v1(numbers);
    std::cout << std::endl;
    
    std::cout << "Reverse v2: ";
    safeReverse_v2(numbers);
    std::cout << std::endl;
    
    std::cout << "Reverse v3: ";
    safeReverse_v3(numbers);
    std::cout << std::endl;
    
    return 0;
}

Output:

Forward: 1 2 3 4 5 
Reverse v1: 5 4 3 2 1 
Reverse v2: 5 4 3 2 1 
Reverse v3: 5 4 3 2 1 

Challenge 2: Safe element removal during iteration

Problem: Remove elements from a vector while iterating without breaking the loop:

#include <vector>
#include <iostream>

// ❌ DANGEROUS: Forward iteration while removing
void dangerousRemoval(std::vector<int>& vec)
{
    // DON'T DO THIS - skips elements after removal
    // for (std::size_t i = 0; i < vec.size(); ++i)
    // {
    //     if (vec[i] % 2 == 0) // Remove even numbers
    //     {
    //         vec.erase(vec.begin() + i); // Shifts all elements left
    //         // Now vec[i] contains what was vec[i+1], but we increment i
    //         // This skips the element that moved into position i
    //     }
    // }
}

// ✅ SAFE: Backward iteration
void safeRemoval_v1(std::vector<int>& vec)
{
    // Iterate backwards to avoid index shifting issues
    for (int i = static_cast<int>(vec.size()) - 1; i >= 0; --i)
    {
        if (vec[i] % 2 == 0) // Remove even numbers
        {
            vec.erase(vec.begin() + i);
        }
    }
}

// ✅ SAFE: Using iterators
void safeRemoval_v2(std::vector<int>& vec)
{
    auto it = vec.begin();
    while (it != vec.end())
    {
        if (*it % 2 == 0) // Remove even numbers
        {
            it = vec.erase(it); // erase returns iterator to next element
        }
        else
        {
            ++it;
        }
    }
}

// ✅ BEST: Using standard algorithms
void safeRemoval_v3(std::vector<int>& vec)
{
    vec.erase(std::remove_if(vec.begin(), vec.end(), 
                            [](int x) { return x % 2 == 0; }), 
              vec.end());
}

int main()
{
    // Test each approach
    std::vector<int> test1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> test2 = test1;
    std::vector<int> test3 = test1;
    
    std::cout << "Original: ";
    for (int num : test1) std::cout << num << " ";
    std::cout << std::endl;
    
    safeRemoval_v1(test1);
    std::cout << "After backward removal: ";
    for (int num : test1) std::cout << num << " ";
    std::cout << std::endl;
    
    safeRemoval_v2(test2);
    std::cout << "After iterator removal: ";
    for (int num : test2) std::cout << num << " ";
    std::cout << std::endl;
    
    safeRemoval_v3(test3);
    std::cout << "After algorithm removal: ";
    for (int num : test3) std::cout << num << " ";
    std::cout << std::endl;
    
    return 0;
}

Output:

Original: 1 2 3 4 5 6 7 8 9 10 
After backward removal: 1 3 5 7 9 
After iterator removal: 1 3 5 7 9 
After algorithm removal: 1 3 5 7 9 

Challenge 3: Comparing arrays of different types

Problem: Compare arrays that might have different signedness:

#include <vector>
#include <iostream>

template<typename T, typename U>
bool safeArrayCompare(const std::vector<T>& vec1, const std::vector<U>& vec2)
{
    // Compare sizes safely
    if (vec1.size() != vec2.size())
    {
        return false;
    }
    
    // Use range-based loops to avoid index issues
    auto it1 = vec1.begin();
    auto it2 = vec2.begin();
    
    while (it1 != vec1.end()) // Both vectors have same size
    {
        if (*it1 != *it2)
        {
            return false;
        }
        ++it1;
        ++it2;
    }
    
    return true;
}

int main()
{
    std::vector<int> signedVec = {1, 2, 3, 4, 5};
    std::vector<unsigned int> unsignedVec = {1, 2, 3, 4, 5};
    std::vector<int> differentVec = {1, 2, 3, 4, 6};
    
    std::cout << "Comparing signed and unsigned vectors:" << std::endl;
    std::cout << "Equal: " << safeArrayCompare(signedVec, unsignedVec) << std::endl;
    std::cout << "Equal to different: " << safeArrayCompare(signedVec, differentVec) << std::endl;
    
    return 0;
}

Output:

Comparing signed and unsigned vectors:
Equal: 1
Equal to different: 0

Challenge 4: Safe array bounds checking

Problem: Check if an index is valid without signed/unsigned comparison issues:

#include <vector>
#include <iostream>

template<typename T>
bool isValidIndex(const std::vector<T>& vec, int index)
{
    // Handle negative indices
    if (index < 0)
    {
        return false;
    }
    
    // Convert to unsigned for comparison
    return static_cast<std::size_t>(index) < vec.size();
}

template<typename T>
T safeGet(const std::vector<T>& vec, int index, const T& defaultValue)
{
    if (isValidIndex(vec, index))
    {
        return vec[index];
    }
    return defaultValue;
}

template<typename T>
bool safeSet(std::vector<T>& vec, int index, const T& value)
{
    if (isValidIndex(vec, index))
    {
        vec[index] = value;
        return true;
    }
    return false;
}

int main()
{
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    
    // Test various indices
    std::vector<int> testIndices = {-1, 0, 1, 2, 3, 100};
    
    for (int index : testIndices)
    {
        std::cout << "Index " << index << ": ";
        
        if (isValidIndex(names, index))
        {
            std::cout << "Valid - " << names[index] << std::endl;
        }
        else
        {
            std::cout << "Invalid" << std::endl;
        }
    }
    
    // Test safe operations
    std::cout << "\nSafe get operations:" << std::endl;
    std::cout << "Index -1: " << safeGet(names, -1, std::string("NOT_FOUND")) << std::endl;
    std::cout << "Index 1: " << safeGet(names, 1, std::string("NOT_FOUND")) << std::endl;
    std::cout << "Index 10: " << safeGet(names, 10, std::string("NOT_FOUND")) << std::endl;
    
    return 0;
}

Output:

Index -1: Invalid
Index 0: Valid - Alice
Index 1: Valid - Bob
Index 2: Valid - Charlie
Index 3: Invalid
Index 100: Invalid

Safe get operations:
Index -1: NOT_FOUND
Index 1: Bob
Index 10: NOT_FOUND

Advanced challenge solutions

Challenge 5: Processing pairs of elements

Problem: Process adjacent pairs of elements without going out of bounds:

#include <vector>
#include <iostream>

void processPairs_v1(const std::vector<int>& vec)
{
    // Using signed arithmetic (safe for reasonable sizes)
    for (int i = 0; i < static_cast<int>(vec.size()) - 1; ++i)
    {
        std::cout << "(" << vec[i] << ", " << vec[i + 1] << ") ";
    }
    std::cout << std::endl;
}

void processPairs_v2(const std::vector<int>& vec)
{
    // Using unsigned arithmetic with careful bounds checking
    if (vec.size() <= 1) return;
    
    for (std::size_t i = 0; i < vec.size() - 1; ++i)
    {
        std::cout << "(" << vec[i] << ", " << vec[i + 1] << ") ";
    }
    std::cout << std::endl;
}

void processPairs_v3(const std::vector<int>& vec)
{
    // Using iterators
    if (vec.empty()) return;
    
    auto it1 = vec.begin();
    auto it2 = it1 + 1;
    
    while (it2 != vec.end())
    {
        std::cout << "(" << *it1 << ", " << *it2 << ") ";
        ++it1;
        ++it2;
    }
    std::cout << std::endl;
}

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    std::vector<int> single = {42};
    std::vector<int> empty;
    
    std::cout << "Processing pairs from [10, 20, 30, 40, 50]:" << std::endl;
    std::cout << "Version 1: ";
    processPairs_v1(numbers);
    std::cout << "Version 2: ";
    processPairs_v2(numbers);
    std::cout << "Version 3: ";
    processPairs_v3(numbers);
    
    std::cout << "\nEdge case - single element:" << std::endl;
    std::cout << "Version 1: ";
    processPairs_v1(single);
    std::cout << "Version 2: ";
    processPairs_v2(single);
    std::cout << "Version 3: ";
    processPairs_v3(single);
    
    std::cout << "\nEdge case - empty vector:" << std::endl;
    std::cout << "Version 1: ";
    processPairs_v1(empty);
    std::cout << "Version 2: ";
    processPairs_v2(empty);
    std::cout << "Version 3: ";
    processPairs_v3(empty);
    
    return 0;
}

Output:

Processing pairs from [10, 20, 30, 40, 50]:
Version 1: (10, 20) (20, 30) (30, 40) (40, 50) 
Version 2: (10, 20) (20, 30) (30, 40) (40, 50) 
Version 3: (10, 20) (20, 30) (30, 40) (40, 50) 

Edge case - single element:
Version 1: 
Version 2: 
Version 3: 

Edge case - empty vector:
Version 1: 
Version 2: 
Version 3: 

Challenge 6: Matrix operations with safe indexing

Problem: Perform operations on 2D vectors with proper bounds checking:

#include <vector>
#include <iostream>

class SafeMatrix
{
private:
    std::vector<std::vector<int>> data;
    
public:
    SafeMatrix(int rows, int cols, int defaultValue = 0)
    {
        data.resize(rows, std::vector<int>(cols, defaultValue));
    }
    
    bool isValidPosition(int row, int col) const
    {
        return row >= 0 && col >= 0 &&
               static_cast<std::size_t>(row) < data.size() &&
               static_cast<std::size_t>(col) < data[0].size();
    }
    
    int get(int row, int col, int defaultValue = 0) const
    {
        if (isValidPosition(row, col))
        {
            return data[row][col];
        }
        return defaultValue;
    }
    
    bool set(int row, int col, int value)
    {
        if (isValidPosition(row, col))
        {
            data[row][col] = value;
            return true;
        }
        return false;
    }
    
    void print() const
    {
        for (std::size_t row = 0; row < data.size(); ++row)
        {
            for (std::size_t col = 0; col < data[row].size(); ++col)
            {
                std::cout << data[row][col] << "\t";
            }
            std::cout << std::endl;
        }
    }
    
    int rows() const { return static_cast<int>(data.size()); }
    int cols() const { return data.empty() ? 0 : static_cast<int>(data[0].size()); }
};

int main()
{
    SafeMatrix matrix(3, 4, 0);
    
    // Fill matrix with some values
    for (int row = 0; row < matrix.rows(); ++row)
    {
        for (int col = 0; col < matrix.cols(); ++col)
        {
            matrix.set(row, col, row * matrix.cols() + col);
        }
    }
    
    std::cout << "Matrix:" << std::endl;
    matrix.print();
    
    // Test boundary access
    std::cout << "\nBoundary tests:" << std::endl;
    std::cout << "(-1, 0): " << matrix.get(-1, 0, -999) << std::endl;
    std::cout << "(1, 2): " << matrix.get(1, 2, -999) << std::endl;
    std::cout << "(10, 10): " << matrix.get(10, 10, -999) << std::endl;
    
    return 0;
}

Output:

Matrix:
0	1	2	3	
4	5	6	7	
8	9	10	11	

Boundary tests:
(-1, 0): -999
(1, 2): 6
(10, 10): -999

Best practices summary

1. Choose the right approach for your needs

// ✅ For simple iteration without index needs
for (const auto& element : container) { /* process element */ }

// ✅ For small-to-medium arrays where you need indices
for (int i = 0; i < static_cast<int>(container.size()); ++i) { /* use i */ }

// ✅ For large arrays or when portability is critical
for (std::size_t i = 0; i < container.size(); ++i) { /* use i */ }

2. Handle edge cases explicitly

// Always check for empty containers when needed
if (!container.empty())
{
    // Safe to access container[0] or container.back()
}

// Validate indices before use
if (index >= 0 && static_cast<std::size_t>(index) < container.size())
{
    // Safe to access container[index]
}

3. Use appropriate tools for the task

// Use standard algorithms when possible
std::remove_if(vec.begin(), vec.end(), predicate);

// Use iterators for complex navigation
auto it = std::find(vec.begin(), vec.end(), value);

// Use range-based loops for simple tasks
for (const auto& item : collection) { /* process */ }

Summary

Working with arrays and loops requires careful attention to signed/unsigned issues:

Key challenges:

• Signed vs unsigned comparisons in loop conditions
• Unsigned integer underflow in reverse iteration
• Index validation with mixed integer types
• Safe element removal during iteration

Solution strategies:

• Cast to appropriate types when needed
• Use range-based loops when indices aren't required
• Implement safe bounds checking utilities
• Choose the right loop type for the task

Best practices:

• Handle edge cases explicitly (empty containers, single elements)
• Validate indices before accessing elements
• Use standard algorithms when appropriate
• Prefer iterators for complex navigation patterns

In the next lesson, you'll learn about range-based for loops (for-each) in greater detail.

Quiz

1. Why is for (std::size_t i = vec.size() - 1; i >= 0; --i) dangerous?
2. What are three safe ways to iterate backwards through a vector?
3. How do you safely remove elements from a vector during forward iteration?
4. When should you cast vector.size() to int vs using std::size_t?
5. What's the safest way to validate an index before using it to access a vector element?

Practice exercises

Try these exercises to practice solving sign-related challenges:

1. Safe utilities library: Create a set of utility functions for safe vector operations: safeGet(), safeSet(), safeFront(), safeBack(), and safeSubvector(). Each should handle edge cases gracefully.

2. Element processor: Write a function that processes every nth element in a vector (e.g., every 3rd element). Handle cases where the vector size isn't evenly divisible by n.

3. Matrix calculator: Implement safe matrix addition, subtraction, and multiplication functions that handle matrices of different sizes gracefully.

4. Array comparator: Create a template function that can safely compare any two arrays/vectors regardless of their element types, handling signed/unsigned comparisons properly.