std::span в C++: Доступ к элементам и итерирование

#include <span>
#include <vector>
 
void processData(std::span<int> data) {
    // Безопасная работа с последовательностью данных
    for (int& value : data) {
        value *= 2;
    }
}
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    int rawArray[] = {6, 7, 8, 9, 10};
    
    // Работает с вектором
    processData(numbers);
    
    // Работает с обычным массивом
    processData(rawArray);
    
    return 0;
}

std::span<int> createSpanWrong() {
    std::vector<int> tempVector = {1, 2, 3}; // Локальный вектор
    return std::span<int>(tempVector); // ОПАСНО! tempVector уничтожится при выходе из функции
} // Возвращаемый span будет указывать на недействительную память

void processPrimitively(int* data, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // Легко сделать ошибку в условии,
        // перепутать знак или написать <= вместо <
        data[i] *= 2;
    }
}

void processVector(std::vector<int>& data) {
    for (auto& value : data) {
        value *= 2;
    }
}
 
// Проблема: требует создания временной копии
void processConstVector(const std::vector<int>& data) {
    std::vector<int> copy = data; // Избыточное копирование!
    // Работаем с копией...
}

void processWithSpan(std::span<int> data) {
    for (int& value : data) {
        value *= 2;
    }
}
 
int main() {
    std::vector<int> vec = {1, 2, 3};
    int arr[] = {4, 5, 6};
    std::array<int, 3> stdarr = {7, 8, 9};
    
    processWithSpan(vec);      // Работает
    processWithSpan(arr);      // Работает
    processWithSpan(stdarr);   // Тоже работает!
    
    return 0;
}

void readOnlyProcess(std::span<const int> data) {
    // Компилятор не даст модифицировать элементы
    for (int value : data) {
        std::cout << value << " ";
    }
}
 
int main() {
    std::vector<int> mutableVec = {1, 2, 3};
    const std::vector<int> constVec = {4, 5, 6};
    
    readOnlyProcess(mutableVec);  // Работает
    readOnlyProcess(constVec);    // Тоже работает
    
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    std::span<int> emptySpan; // Пустой span
    std::cout << "Размер: " << emptySpan.size() << std::endl; // Выведет "Размер: 0"
    
    // Проверка на пустоту
    if (emptySpan.empty()) {
        std::cout << "Span пуст" << std::endl;
    }
    
    return 0;
}

int arr[] = {1, 2, 3, 4, 5};
std::span<int> arraySpan(arr, 5); // Указатель на начало и число элементов

// Для статических массивов компилятор сам определит размер
int staticArr[] = {10, 20, 30, 40, 50};
std::span<int> staticArraySpan(staticArr);
 
// Для std::array тоже работает автоматический вывод размера
std::array<double, 3> stdArray = {1.1, 2.2, 3.3};
std::span<double> arraySpan(stdArray);

#include <span>
#include <vector>
#include <array>
#include <iostream>
 
void printSpan(std::span<const int> sp) {
    for (int value : sp) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}
 
int main() {
    // Из std::vector
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::span<int> vectorSpan(vec);
    
    // Из обычного массива C
    int cArray[] = {6, 7, 8, 9, 10};
    std::span<int> cArraySpan(cArray);
    
    // Из std::array
    std::array<int, 3> stdArr = {11, 12, 13};
    std::span<int> stdArraySpan(stdArr);
    
    // Демонстрация работы
    printSpan(vectorSpan);
    printSpan(cArraySpan);
    printSpan(stdArraySpan);
    
    return 0;
}

// Динамический размер (определяется во время выполнения)
std::span<int> dynamicSpan = {...}; 
 
// Статический размер (известен на этапе компиляции)
std::span<int, 5> staticSpan = {...};  
 
// Специальный случай для пустого span
std::span<int, 0> emptyStaticSpan = {};
 
// Можно использовать std::dynamic_extent для явного указания динамического размера
std::span<int, std::dynamic_extent> explicitDynamicSpan = {...};

template <std::size_t N>
void processFixed(std::span<int, N> data) {
    // Размер известен компилятору
    // Можно выполнить оптимизации на основе этого
    static_assert(N > 0, "Empty spans are not supported");
    
    // Можно использовать N как константу
    constexpr size_t halfSize = N / 2;
    
    // Работаем с данными...
}
 
int main() {
    int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::span<int, 10> fixedSpan(data);
    
    processFixed(fixedSpan);  // Работает
    
    // processFixed(std::span<int>(data, 8)); 
    // Ошибка! Размер не соответствует шаблонному параметру
    
    return 0;
}

std::vector<int> numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
// Создаем span для всего вектора
std::span<int> fullSpan(numbers);
 
// Создаем span для части вектора, начиная с 3-го элемента (индекс 2)
// и длиной 4 элемента
std::span<int> partialSpan(numbers.data() + 2, 4);
 
// Вывод: 2 3 4 5
for (int val : partialSpan) {
    std::cout << val << " ";
}

// Создание span для константных данных из неконстантных
std::vector<int> mutableData = {1, 2, 3};
std::span<const int> constView(mutableData);  // Работает
 
// Создание span для байтового представления данных
struct Point { float x, y; };
Point points[] = {{1.0f, 2.0f}, {3.0f, 4.0f}};
std::span<Point> pointSpan(points);
 
// Просмотр точек как последовательности байтов
std::span<const std::byte> byteSpan(
    reinterpret_cast<const std::byte*>(pointSpan.data()),
    pointSpan.size_bytes()
);

#include <span>
#include <iostream>
 
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    std::span<int> mySpan(arr);
    
    // Доступ через оператор []
    std::cout << "Элемент с индексом 2: " << mySpan[2] << std::endl; // Выведет 30
    
    // Изменение элемента
    mySpan[1] = 25;
    std::cout << "Измененный массив: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " "; // Выведет 10 25 30 40 50
    }
    
    return 0;
}

#include <span>
#include <iostream>
#include <stdexcept>
 
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    std::span<int> mySpan(arr);
    
    try {
        // Безопасный доступ с проверкой границ
        std::cout << "Элемент с индексом 2: " << mySpan.at(2) << std::endl;
        
        // Обращение к несуществующему индексу
        std::cout << "Элемент с индексом 10: " << mySpan.at(10) << std::endl;
    } catch (const std::out_of_range& e) {
        std::cerr << "Ошибка выхода за границы: " << e.what() << std::endl;
    }
    
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    std::span<int> mySpan(arr);
    
    // Доступ к первому элементу
    std::cout << "Первый элемент: " << mySpan.front() << std::endl;
    
    // Доступ к последнему элементу
    std::cout << "Последний элемент: " << mySpan.back() << std::endl;
    
    // Изменение первого и последнего элементов
    mySpan.front() = 100;
    mySpan.back() = 500;
    
    // Проверка изменений
    std::cout << "После модификации: " << arr[0] << " ... " << arr[4] << std::endl;
    
    return 0;
}

if (!mySpan.empty()) {
    int first = mySpan.front();
    // Работаем с элементом...
}

#include <span>
#include <memory>
 
void processWithSpan(std::span<int> data) {
    // Обработка данных...
}
 
int main() {
    // Правильно: умный указатель гарантирует время жизни
    auto dynamicArray = std::make_unique<int[]>(100);
    std::span<int> safeSpan(dynamicArray.get(), 100);
    processWithSpan(safeSpan);
    
    // Неправильно: память освобождается после функции
    auto createTempSpan() {
        int* data = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        std::span<int> tempSpan(data, 10); // Опасно!
        return tempSpan;
    } // Утечка памяти + возвращаемый span указывает на память, 
      // которую нужно было бы освободить
    
    return 0;
}

#include <span>
#include <string>
 
void printChars(std::span<const char> chars) {
    for (char c : chars) {
        std::cout << c;
    }
    std::cout << std::endl;
}
 
int main() {
    // Строковый литерал включает завершающий нулевой символ!
    const char* literal = "Hello";
    std::span<const char> literalSpan(literal, 5); // Не включаем '\0'
    
    // Работа со std::string
    std::string str = "World";
    std::span<const char> stringSpan(str.data(), str.size());
    
    printChars(literalSpan); // Выводит "Hello"
    printChars(stringSpan);  // Выводит "World"
    
    return 0;
}

#include <span>
#include <deque>
#include <vector>
 
int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};
    
    // Так не сработает! deque не хранит данные непрерывно
    // std::span<int> dequeSpan(myDeque);
    
    // Правильный способ: создаем промежуточный вектор
    std::vector<int> vec(myDeque.begin(), myDeque.end());
    std::span<int> vecSpan(vec);
    
    return 0;
}

#include <span>
#include <vector>
 
struct Pixel {
    uint8_t r, g, b, a;
};
 
void processRedChannel(std::span<uint8_t> redValues) {
    // Обработка только красного канала
}
 
int main() {
    std::vector<Pixel> image(1000);
    
    // Создаем span для доступа только к красному каналу первого пикселя
    // Обратите внимание на приведение типа!
    std::span<uint8_t> redChannel(&image[0].r, 1);
    
    // Это не будет работать для всех красных каналов сразу,
    // так как данные не расположены непрерывно
    
    return 0;
}

#include <span>
#include <vector>
 
struct Point3D {
    float x, y, z;
};
 
void normalizePoints(std::span<Point3D> points) {
    for (auto& p : points) {
        float len = std::sqrt(p.x*p.x + p.y*p.y + p.z*p.z);
        if (len > 0) {
            p.x /= len;
            p.y /= len;
            p.z /= len;
        }
    }
}
 
int main() {
    std::vector<Point3D> vertices = {{1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}};
    normalizePoints(vertices);
    
    return 0;
}

#include <span>
#include <iostream>
 
void demonstrateBoundaryChecks() {
    int arr[] = {1, 2, 3, 4, 5};
    std::span<int> sp(arr);
    
    // Оператор [] не проверяет границы
    int value1 = sp[2];  // Безопасно
    // int value2 = sp[10]; // Неопределенное поведение!
    
    // Метод at() проверяет границы
    int value3 = sp.at(2);  // Безопасно
    // int value4 = sp.at(10); // Выбросит исключение std::out_of_range
}

#include <span>
#include <iostream>
#include <stdexcept>
 
bool accessElementSafely(std::span<int> data, size_t index, int& result) {
    try {
        result = data.at(index);
        return true;
    } catch (const std::out_of_range& e) {
        std::cerr << "Ошибка доступа: " << e.what() << std::endl;
        return false;
    }
}
 
int main() {
    int arr[] = {10, 20, 30};
    std::span<int> sp(arr);
    
    int value;
    if (accessElementSafely(sp, 1, value)) {
        std::cout << "Значение: " << value << std::endl;  // Успешно
    }
    
    if (accessElementSafely(sp, 5, value)) {
        std::cout << "Значение: " << value << std::endl;  // Не выполнится
    } else {
        std::cout << "Не удалось получить значение по индексу 5" << std::endl;
    }
    
    return 0;
}

#include <span>
#include <iostream>
 
void processSpanSafely(std::span<const int> data) {
    if (data.empty()) {
        std::cout << "Span пуст, обработка невозможна" << std::endl;
        return;
    }
    
    // Теперь безопасно использовать front() и back()
    std::cout << "Первый элемент: " << data.front() << std::endl;
    std::cout << "Последний элемент: " << data.back() << std::endl;
    
    // Можно проверить, достаточно ли элементов для операции
    if (data.size() >= 3) {
        std::cout << "Третий элемент: " << data[2] << std::endl;
    }
}

#include <span>
#include <iostream>
#include <algorithm>
 
void iterateWithBoundsChecking(std::span<int> data) {
    // Range-based for автоматически соблюдает границы
    for (int& value : data) {
        value *= 2;
    }
    
    // Алгоритмы STL соблюдают границы, если передать корректные итераторы
    std::for_each(data.begin(), data.end(), [](int& value) {
        value += 1;
    });
    
    // Индексная итерация требует явной проверки границ
    for (size_t i = 0; i < data.size(); ++i) {
        data[i] -= 1;  // Безопасно, т.к. i < data.size()
    }
}

#include <span>
#include <array>
 
template <size_t N>
constexpr bool isIndexValid(std::span<int, N> data, size_t index) {
    return index < N;
}
 
int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};
    std::span<int, 5> sp(arr);
    
    // Проверка на этапе компиляции
    static_assert(isIndexValid(sp, 4), "Index 4 is valid");
    // static_assert(isIndexValid(sp, 5), "Index 5 is invalid"); // Ошибка компиляции
    
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    std::span<int> mySpan(arr);
    
    // Итерация с использованием явных итераторов
    std::cout << "Итерация с begin/end: ";
    for (auto it = mySpan.begin(); it != mySpan.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    std::span<int> mySpan(arr);
    
    // Использование range-based for
    std::cout << "Range-based цикл: ";
    for (int value : mySpan) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    // Модификация элементов через ссылку
    for (int& value : mySpan) {
        value *= 2;
    }
    
    std::cout << "После модификации: ";
    for (int value : mySpan) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    int arr[] = {5, 4, 3, 2, 1};
    std::span<int> mySpan(arr);
    
    std::cout << "Обратная итерация: ";
    for (auto it = mySpan.rbegin(); it != mySpan.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <iostream>
#include <algorithm>
 
int main() {
    int arr[] = {3, 1, 4, 1, 5, 9};
    std::span<int> mySpan(arr);
    
    // Использование константных итераторов для поиска
    auto it = std::find(mySpan.cbegin(), mySpan.cend(), 5);
    if (it != mySpan.cend()) {
        std::cout << "Элемент 5 найден на позиции: " 
                  << std::distance(mySpan.cbegin(), it) << std::endl;
    }
    
    return 0;
}

#include <span>
#include <algorithm>
#include <iostream>
 
bool isPrime(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}
 
int main() {
    int values[] = {4, 7, 12, 19, 23, 42, 11};
    std::span<int> valuesSpan(values);
    
    // Поиск конкретного значения
    auto it = std::find(valuesSpan.begin(), valuesSpan.end(), 19);
    if (it != valuesSpan.end()) {
        std::cout << "Найдено число 19 на позиции: " 
                  << std::distance(valuesSpan.begin(), it) << std::endl;
    }
    
    // Поиск первого простого числа
    auto primeIt = std::find_if(valuesSpan.begin(), valuesSpan.end(), isPrime);
    if (primeIt != valuesSpan.end()) {
        std::cout << "Первое простое число: " << *primeIt << std::endl;
    }
    
    return 0;
}

#include <span>
#include <algorithm>
#include <iostream>
 
int main() {
    int data[] = {9, 1, 8, 2, 7, 3, 6, 4, 5};
    std::span<int> dataSpan(data);
    
    // Сортировка
    std::sort(dataSpan.begin(), dataSpan.end());
    
    std::cout << "Отсортированные данные: ";
    for (int val : dataSpan) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    // Применение трансформации к каждому элементу
    std::transform(dataSpan.begin(), dataSpan.end(), dataSpan.begin(),
                   [](int val) { return val * val; });
    
    std::cout << "После возведения в квадрат: ";
    for (int val : dataSpan) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <numeric>
#include <iostream>
 
int main() {
    int values[] = {1, 2, 3, 4, 5};
    std::span<int> valuesSpan(values);
    
    // Вычисление суммы
    int sum = std::accumulate(valuesSpan.begin(), valuesSpan.end(), 0);
    std::cout << "Сумма элементов: " << sum << std::endl;
    
    // Вычисление произведения
    int product = std::accumulate(valuesSpan.begin(), valuesSpan.end(), 1,
                                 [](int a, int b) { return a * b; });
    std::cout << "Произведение элементов: " << product << std::endl;
    
    return 0;
}

#include <span>
#include <ranges>
#include <algorithm>
#include <iostream>
 
int main() {
    int data[] = {1, 3, 5, 7, 9, 2, 4, 6, 8};
    std::span<int> dataSpan(data);
    
    // Использование диапазонных адаптеров
    auto evenNumbers = dataSpan | std::views::filter([](int n) { return n % 2 == 0; });
    
    std::cout << "Четные числа: ";
    for (int val : evenNumbers) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <vector>
#include <array>
 
// Вместо множества перегрузок...
/*
void process(int* arr, size_t size);
void process(std::vector<int>& vec);
void process(std::array<int, N>& arr);
*/
 
// Одна универсальная функция
void process(std::span<int> data) {
    // Логика обработки данных
    for (auto& value : data) {
        value = value * 2 + 1;
    }
}
 
int main() {
    int rawArray[] = {1, 2, 3};
    std::vector<int> vec = {4, 5, 6};
    std::array<int, 3> arr = {7, 8, 9};
    
    // Работает с любым типом
    process(rawArray);
    process(vec);
    process(arr);
    
    return 0;
}

#include <span>
#include <vector>
#include <chrono>
#include <iostream>
 
// Неоптимальный подход: копирование большого массива данных
void processByValue(std::vector<double> data) {
    double sum = 0;
    for (auto val : data) {
        sum += val;
    }
}
 
// Подход с использованием span: без копирования
void processWithSpan(std::span<const double> data) {
    double sum = 0;
    for (auto val : data) {
        sum += val;
    }
}
 
int main() {
    // Создаем большой вектор
    const int SIZE = 10000000; // 10 миллионов элементов
    std::vector<double> largeData(SIZE, 1.0);
    
    // Замеряем время выполнения с копированием
    auto start = std::chrono::high_resolution_clock::now();
    processByValue(largeData);
    auto end = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    // Замеряем время выполнения со span
    start = std::chrono::high_resolution_clock::now();
    processWithSpan(largeData);
    end = std::chrono::high_resolution_clock::now();
    auto duration2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    std::cout << "Время с копированием: " << duration1.count() << " мс\n";
    std::cout << "Время со span: " << duration2.count() << " мс\n";
    
    return 0;
}

#include <span>
#include <vector>
#include <cstring> // для memcpy
 
// Оптимизированная функция для копирования данных блоками
void optimizedCopy(std::span<const int> source, std::span<int> destination) {
    if (source.size() != destination.size()) {
        throw std::invalid_argument("Размеры не совпадают");
    }
    
    // Прямой доступ к исходным данным через data()
    std::memcpy(destination.data(), source.data(), 
                source.size() * sizeof(int));
}
 
int main() {
    std::vector<int> source = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> dest(10);
    
    optimizedCopy(source, dest);
    
    // Проверка результатов
    for (int val : dest) {
        std::cout << val << " ";
    }
    
    return 0;
}

#include <span>
#include <vector>
#include <iostream>
 
// Функция для обработки сигнала с использованием скользящего окна
std::vector<double> movingAverage(std::span<const double> signal, size_t windowSize) {
    if (signal.size() < windowSize) {
        return {};
    }
    
    std::vector<double> result(signal.size() - windowSize + 1);
    
    for (size_t i = 0; i < result.size(); ++i) {
        // Создаем временное окно как подвид исходного span
        std::span<const double> window = signal.subspan(i, windowSize);
        
        // Вычисляем среднее для окна
        double sum = 0;
        for (double value : window) {
            sum += value;
        }
        
        result[i] = sum / windowSize;
    }
    
    return result;
}
 
int main() {
    std::vector<double> signal = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
    
    auto averages = movingAverage(signal, 3);
    
    std::cout << "Скользящее среднее (окно = 3): ";
    for (double avg : averages) {
        std::cout << avg << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <vector>
#include <thread>
#include <iostream>
 
// Функция для параллельной обработки части данных
void processChunk(std::span<int> chunk) {
    for (auto& val : chunk) {
        val = val * val; // Простая операция
    }
}
 
int main() {
    const int SIZE = 1000000;
    std::vector<int> largeData(SIZE);
    
    // Инициализация
    for (int i = 0; i < SIZE; ++i) {
        largeData[i] = i % 100;
    }
    
    const int NUM_THREADS = 4;
    const int CHUNK_SIZE = SIZE / NUM_THREADS;
    
    std::thread threads[NUM_THREADS];
    
    // Запускаем потоки, каждый обрабатывает свой кусок данных
    for (int i = 0; i < NUM_THREADS; ++i) {
        int offset = i * CHUNK_SIZE;
        int length = (i == NUM_THREADS - 1) ? (SIZE - offset) : CHUNK_SIZE;
        
        threads[i] = std::thread(processChunk, 
                                std::span<int>(largeData).subspan(offset, length));
    }
    
    // Ждем завершения всех потоков
    for (auto& thread : threads) {
        thread.join();
    }
    
    return 0;
}

std::span<int> createDanglingSpan() {
    std::vector<int> localVector = {1, 2, 3, 4, 5};
    return std::span<int>(localVector); // Опасно!
} // localVector уничтожается здесь, оставляя висячий указатель

void safeUsage(std::vector<int>& vec) {
    std::span<int> safeSpan(vec);
    // Работа со span...
} // span уничтожается до вектора

std::vector<int> data = {1, 2, 3};
std::span<int> mySpan(data);
 
data.push_back(4); // Потенциальная проблема!
// mySpan может указывать на недействительную память, 
// если произошло перевыделение

std::vector<int> data = {1, 2, 3};
data.push_back(4); // Сначала модифицируем
 
std::span<int> mySpan(data); // Затем создаём span

void processData(std::span<int> data) {
    // Модифицирует данные...
}
 
void processConstData(std::span<const int> data) {
    // Только читает данные...
}
 
int main() {
    const std::vector<int> constData = {1, 2, 3};
    std::vector<int> mutableData = {4, 5, 6};
    
    processConstData(constData);  // OK
    processConstData(mutableData); // OK
    
    processData(mutableData);  // OK
    // processData(constData);  // Ошибка компиляции
    
    return 0;
}

template <std::size_t N>
void processFixedSize(std::span<int, N> data) {
    // ...
}
 
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // Компилируется, но может привести к ошибкам, если vec.size() != 5
    processFixedSize<5>(std::span<int, 5>(vec.data(), 5));
    
    // Безопаснее проверить размер явно
    if (vec.size() >= 5) {
        processFixedSize<5>(std::span<int, 5>(vec.data(), 5));
    }
    
    return 0;
}

void threadFunction(std::span<int> data) {
    // Небезопасный доступ к данным из разных потоков
    for (auto& val : data) {
        val += 1; // Гонка данных, если другие потоки тоже модифицируют элементы
    }
}

void processWithPointer(int* data, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // Обработка data[i]
    }
}

template <typename Container>
void processWithContainerRef(Container& container) {
    for (auto& element : container) {
        // Обработка element
    }
}

void processRefWrappers(std::vector<std::reference_wrapper<int>> refs) {
    for (auto& ref : refs) {
        int& value = ref.get();
        // Обработка value
    }
}

void processStringView(std::string_view sv) {
    for (char c : sv) {
        // Обработка символа c
    }
}

    // Вместо:
    void calculateStats(const std::vector<double>& data);
    void calculateStats(const double* data, size_t size);
 
    // Лучше:
    void calculateStats(std::span<const double> data);

    template <typename T>
    double average(std::span<const T> values) {
        if (values.empty()) return 0.0;
        
        T sum = 0;
        for (const auto& val : values) {
            sum += val;
        }
        return static_cast<double>(sum) / values.size();
    }

    void processChunks(std::span<int> data) {
        const size_t chunkSize = 1024;
        for (size_t offset = 0; offset < data.size(); offset += chunkSize) {
            auto chunk = data.subspan(
                offset, std::min(chunkSize, data.size() - offset)
            );
            processChunk(chunk);
        }
    }

    void highPerformanceAlgorithm(std::span<const float> inputs,
                                  std::span<float> outputs) {
        // Прямой доступ к данным без копирования
        // ...
    }

    // Менее ясно, что происходит с данными
    void processData(int* data, size_t size);
    
    // Очевидно, что функция только просматривает данные
    void processData(std::span<const int> data);

    // Неправильно: span не гарантирует время жизни данных
    std::span<int> createAndReturnSpan() {
        static std::vector<int> data = {1, 2, 3}; // Хак с static
        return data;
    }
    
    // Правильно: функция возвращает сам контейнер
    std::vector<int> createAndReturnVector() {
        return {1, 2, 3};
    }

    std::list<int> myList = {1, 2, 3};
    // std::span<int> listSpan(myList); // Ошибка! Элементы не непрерывны в памяти

    std::vector<int> vec = {1, 2, 3};
    std::span<int> spanToVec(vec);
    
    vec.push_back(4); // Может привести к перевыделению!
    // spanToVec теперь может указывать на недействительную память

    // Внешняя функция из старой библиотеки
    extern void legacyFunction(const int* data, size_t size);
    
    void modernWrapper(std::span<const int> data) {
        legacyFunction(data.data(), data.size());
    }

#include <span>
#include <vector>
#include <chrono>
#include <iostream>
 
// Функция, использующая указатель и размер
void sumWithPointer(const int* data, size_t size, int& result) {
    result = 0;
    for (size_t i = 0; i < size; ++i) {
        result += data[i];
    }
}
 
// Эквивалентная функция с использованием span
void sumWithSpan(std::span<const int> data, int& result) {
    result = 0;
    for (auto val : data) {
        result += val;
    }
}
 
int main() {
    const int SIZE = 10000000;
    std::vector<int> largeData(SIZE, 1);
    
    int result;
    auto start = std::chrono::high_resolution_clock::now();
    
    // Тест с указателем
    for (int i = 0; i < 100; ++i) {
        sumWithPointer(largeData.data(), largeData.size(), result);
    }
    
    auto mid = std::chrono::high_resolution_clock::now();
    
    // Тест со span
    for (int i = 0; i < 100; ++i) {
        sumWithSpan(largeData, result);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    
    auto pointerTime = std::chrono::duration_cast<std::chrono::milliseconds>(mid - start).count();
    auto spanTime = std::chrono::duration_cast<std::chrono::milliseconds>(end - mid).count();
    
    std::cout << "Время с указателем: " << pointerTime << " мс\n";
    std::cout << "Время со span: " << spanTime << " мс\n";
    std::cout << "Отношение (span/pointer): " << static_cast<double>(spanTime) / pointerTime << "\n";
    
    return 0;
}