/*
  Demonstrates the conceptual difference between stack and heap allocation.
  Note: Actual performance differences are complex and depend on many factors.
  This example primarily illustrates where memory resides.
*/

#include <iostream>
#include <array>    // For std::array
#include <vector>   // For std::vector
#include <chrono>   // For timing

// Function to perform a simple sum on a stack-allocated array
long long sum_stack_array(const std::array<int, 100000> &arr) {
    long long total = 0;
    for (int x : arr) {
        total += x;
    }
    return total;
}

// Function to perform a simple sum on a heap-allocated vector
long long sum_heap_vector(const std::vector<int> &vec) {
    long long total = 0;
    for (int x : vec) {
        total += x;
    }
    return total;
}

int main() {
    // --- Stack Allocation with std::array ---
    std::cout << "\n--- Stack Allocation (std::array) ---\n";
    // std::array is allocated directly on the stack (if small enough)
    // Its size is known at compile time.
    std::array<int, 100000> stack_data; 

    // Initialize with dummy data
    for (size_t i = 0; i < stack_data.size(); ++i) {
        stack_data[i] = static_cast<int>(i);
    }

    auto start_stack = std::chrono::high_resolution_clock::now();
    long long stack_sum = sum_stack_array(stack_data);
    auto end_stack = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> stack_duration = end_stack - start_stack;

    std::cout << "std::array sum: " << stack_sum << "\n";
    std::cout << "std::array processing time: " << stack_duration.count() << " ms\n";
    std::cout << "std::array memory address (first element): " << &stack_data[0] << "\n";
    std::cout << "(Memory for stack_data is typically adjacent to other local variables on the stack.)\n";

    // --- Heap Allocation with std::vector ---
    std::cout << "\n--- Heap Allocation (std::vector) ---\n";
    // std::vector allocates its elements on the heap.
    // The vector object itself (pointer, size, capacity) is on the stack.
    std::vector<int> heap_data(100000);

    // Initialize with dummy data
    for (size_t i = 0; i < heap_data.size(); ++i) {
        heap_data[i] = static_cast<int>(i);
    }

    auto start_heap = std::chrono::high_resolution_clock::now();
    long long heap_sum = sum_heap_vector(heap_data);
    auto end_heap = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> heap_duration = end_heap - start_heap;

    std::cout << "std::vector sum: " << heap_sum << "\n";
    std::cout << "std::vector processing time: " << heap_duration.count() << " ms\n";
    std::cout << "std::vector's internal data address (first element): " << &heap_data[0] << "\n";
    std::cout << "(Memory for heap_data elements is typically allocated from the free store.)\n";
    std::cout << "std::vector object address (on stack): " << &heap_data << "\n";

    std::cout << "\nKey takeaway: std::array often provides better cache locality and less overhead for fixed-size data.\n";

    return 0;
}

/*
  Illustrates basic usage of std::array, highlighting its compile-time size
  and direct memory access, similar to a C-style array but with STL benefits.
*/

#include <iostream>
#include <array>
#include <numeric> // For std::accumulate
#include <algorithm> // For std::sort

int main() {
    // --- Declaration and Initialization ---
    std::cout << "\n--- Declaration and Initialization ---\n";
    // Declare an std::array of 5 integers, initialized to 0.
    // The size 5 is a compile-time constant.
    std::array<int, 5> fixed_size_buffer{}; 

    // Initialize with a list (aggregate initialization)
    std::array<double, 3> sensor_readings = {10.5, 22.3, 15.1};

    std::cout << "Initial fixed_size_buffer elements:\n";
    for (size_t i = 0; i < fixed_size_buffer.size(); ++i) {
        std::cout << "  Element " << i << ": " << fixed_size_buffer[i] << "\n";
    }

    // --- Element Access ---
    std::cout << "\n--- Element Access ---\n";
    // Access elements directly using operator[] (no bounds checking in release builds)
    fixed_size_buffer[0] = 10;
    fixed_size_buffer[1] = 20;
    
    // Access with bounds checking using .at() (throws std::out_of_range on error)
    try {
        fixed_size_buffer.at(2) = 30;
        fixed_size_buffer.at(4) = 50;
        // fixed_size_buffer.at(5) = 60; // This would throw an exception
    } catch (const std::out_of_range& e) {
        std::cerr << "Error accessing fixed_size_buffer: " << e.what() << "\n";
    }

    std::cout << "Updated fixed_size_buffer elements:\n";
    for (int val : fixed_size_buffer) { // Range-based for loop
        std::cout << "  " << val << "\n";
    }

    // --- STL Algorithm Compatibility ---
    std::cout << "\n--- STL Algorithm Compatibility ---\n";
    // std::array provides iterators, making it compatible with STL algorithms
    std::cout << "Sensor readings: ";
    for (double val : sensor_readings) {
        std::cout << val << " ";
    }
    std::cout << "\n";

    // Sum elements using std::accumulate
    double sum = std::accumulate(sensor_readings.begin(), sensor_readings.end(), 0.0);
    std::cout << "Sum of sensor readings: " << sum << "\n";

    // Sort elements using std::sort
    std::sort(sensor_readings.begin(), sensor_readings.end());
    std::cout << "Sorted sensor readings: ";
    for (double val : sensor_readings) {
        std::cout << val << " ";
    }
    std::cout << "\n";

    // --- Size Information ---
    std::cout << "\n--- Size Information ---\n";
    std::cout << "Size of fixed_size_buffer: " << fixed_size_buffer.size() << "\n";
    std::cout << "Max size of fixed_size_buffer: " << fixed_size_buffer.max_size() << "\n";

    // Raw array access (for interoperability with C-style functions)
    int* raw_ptr = fixed_size_buffer.data();
    std::cout << "Raw pointer to fixed_size_buffer data: " << raw_ptr << "\n";
    std::cout << "First element via raw pointer: " << raw_ptr[0] << "\n";

    return 0;
}

/*
  Demonstrates how std::array can be leveraged for performance-critical scenarios,
  focusing on cache efficiency and direct manipulation for small, fixed buffers.
*/

#include <iostream>
#include <array>
#include <numeric> // For std::fill, std::iota
#include <chrono>  // For timing
#include <algorithm> // For std::transform

// A simple function simulating processing on a fixed-size buffer
void process_fixed_buffer(std::array<float, 256>& buffer) {
    // Simulate some computation: double each element
    for (float& val : buffer) {
        val *= 2.0f;
    }
}

// Function for a small 3D vector (common in graphics/physics)
struct Vec3 {
    std::array<float, 3> coords;

    // Overload operator for vector addition
    Vec3 operator+(const Vec3& other) const {
        Vec3 result;
        for (size_t i = 0; i < 3; ++i) {
            result.coords[i] = coords[i] + other.coords[i];
        }
        return result;
    }

    // Method to print the vector
    void print() const {
        std::cout << "(" << coords[0] << ", " << coords[1] << ", " << coords[2] << ")";
    }
};

int main() {
    std::cout << "\n--- Leveraging std::array for Cache Efficiency ---\n";
    // --- Scenario 1: Small fixed-size I/O or processing buffer ---
    std::array<float, 256> data_buffer; // A common buffer size (e.g., for network packets, audio samples)
    
    // Initialize with sequential values
    std::iota(data_buffer.begin(), data_buffer.end(), 0.0f);

    std::cout << "Initial buffer (first 5 elements): ";
    for (size_t i = 0; i < 5; ++i) {
        std::cout << data_buffer[i] << " ";
    }
    std::cout << "...\n";

    auto start_process = std::chrono::high_resolution_clock::now();
    process_fixed_buffer(data_buffer); // Process the buffer
    auto end_process = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::micro> process_duration = end_process - start_process;

    std::cout << "Processed buffer (first 5 elements): ";
    for (size_t i = 0; i < 5; ++i) {
        std::cout << data_buffer[i] << " ";
    }
    std::cout << "...\n";
    std::cout << "Buffer processing time: " << process_duration.count() << " microseconds\n";

    std::cout << "(std::array's contiguous memory and stack allocation minimize cache misses for such operations.)\n";

    // --- Scenario 2: Fixed-size structures (e.g., 3D vectors/matrices) ---
    std::cout << "\n--- std::array in Custom Fixed-Size Structures (Vec3) ---\n";
    Vec3 v1 = {{{1.0f, 2.0f, 3.0f}}}; // Note the nested braces for aggregate initialization
    Vec3 v2 = {{{4.0f, 5.0f, 6.0f}}};

    std::cout << "Vector 1: "; v1.print(); std::cout << "\n";
    std::cout << "Vector 2: "; v2.print(); std::cout << "\n";

    Vec3 v_sum = v1 + v2; // Use the overloaded operator
    std::cout << "Vector Sum: "; v_sum.print(); std::cout << "\n";

    std::cout << "(Using std::array within structs ensures stack allocation for the data and maintains cache efficiency.)\n";

    return 0;
}

/*
  Illustrates the limitations of std::array and when to consider alternatives.
  Specifically, passing by value (expensive) vs. passing by reference (efficient).
  Also shows a large array that might cause stack overflow.
*/

#include <iostream>
#include <array>
#include <numeric>
#include <chrono>

// Function that takes std::array by value - INEFFECIENT for large arrays!
// This creates a full copy of the array on the stack.
void process_by_value(std::array<int, 10000> arr_copy) {
    arr_copy[0] = -1; // Only modifies the copy
}

// Function that takes std::array by reference - EFFICIENT!
// No copy is made; operates on the original array.
void process_by_reference(std::array<int, 10000>& arr_ref) {
    arr_ref[0] = -1; // Modifies the original array
}

// Function that takes std::array by const reference - EFFICIENT and SAFE for read-only!
// No copy is made; guarantees the original array is not modified.
void process_by_const_reference(const std::array<int, 10000>& arr_const_ref) {
    // arr_const_ref[0] = -1; // ERROR: cannot modify a const reference
    long long sum = 0;
    for(int x : arr_const_ref) {
        sum += x;
    }
    std::cout << "Sum from const ref: " << sum << "\n";
}

// A function that could potentially cause stack overflow if called recursively
// or if 'huge_array' was much larger. Not recommended for typical use.
void demonstrate_large_array_risk() {
    // WARNING: This size might cause a stack overflow on some systems/configurations.
    // Stack size is typically limited (e.g., 8MB on Windows, configurable on Linux).
    // This is for demonstration ONLY. Avoid excessively large stack allocations.
    // On a typical system, 10 million integers might be 40MB, definitely too large for stack.
    // std::array<int, 10000000> huge_array; // Uncomment with caution for testing stack overflow
    std::cout << "(Commented out: A std::array of 10 million ints would likely cause stack overflow.)\n";
    std::cout << "Always be mindful of stack size limits when using large std::array instances.\n";
}

int main() {
    std::cout << "\n--- Demonstrating std::array Limitations & Best Practices ---\n";
    
    std::array<int, 10000> my_array;
    std::iota(my_array.begin(), my_array.end(), 1);

    std::cout << "Original my_array[0]: " << my_array[0] << "\n";

    // --- Passing by Value --- 
    // Creates a copy; expensive for large arrays.
    std::cout << "\n--- Passing by Value (Inefficient for large arrays) ---\n";
    auto start_value = std::chrono::high_resolution_clock::now();
    process_by_value(my_array);
    auto end_value = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::micro> value_duration = end_value - start_value;
    std::cout << "my_array[0] after process_by_value: " << my_array[0] << " (unchanged)\n";
    std::cout << "Time for pass by value: " << value_duration.count() << " microseconds\n";

    // --- Passing by Reference ---
    // No copy; efficient, allows modification.
    std::cout << "\n--- Passing by Reference (Efficient, allows modification) ---\n";
    auto start_ref = std::chrono::high_resolution_clock::now();
    process_by_reference(my_array);
    auto end_ref = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::micro> ref_duration = end_ref - start_ref;
    std::cout << "my_array[0] after process_by_reference: " << my_array[0] << " (modified)\n";
    std::cout << "Time for pass by reference: " << ref_duration.count() << " microseconds\n";

    // Restore original value for const reference test
    my_array[0] = 1;

    // --- Passing by Const Reference ---
    // No copy; efficient, prevents modification.
    std::cout << "\n--- Passing by Const Reference (Efficient, read-only) ---\n";
    auto start_const_ref = std::chrono::high_resolution_clock::now();
    process_by_const_reference(my_array);
    auto end_const_ref = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::micro> const_ref_duration = end_const_ref - start_const_ref;
    std::cout << "my_array[0] after process_by_const_reference: " << my_array[0] << " (unchanged)\n";
    std::cout << "Time for pass by const reference: " << const_ref_duration.count() << " microseconds\n";

    std::cout << "\n(Observe the significant difference in timing and behavior between pass-by-value and pass-by-reference.)\n";

    demonstrate_large_array_risk();

    return 0;
}