std::span в C++: Введение в невладеющее представление

void processArray(int* data, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // Обработка элементов
    }
}

void processArray(std::span<int> data) {
    for (auto elem : data) {
        // Обработка элементов
    }
}

void processPart(int* start, size_t count);
 
std::vector<int> vec = {1, 2, 3, 4, 5};
processPart(&vec[1], 3); // Обработка элементов 2, 3, 4

void processPart(std::span<int> data);
 
std::vector<int> vec = {1, 2, 3, 4, 5};
processPart(std::span(vec).subspan(1, 3)); // Явно создаем подмножество

template <class T, size_t Extent = dynamic_extent>
class span {
public:
    // Типы и константы
    using element_type = T;
    using value_type = typename std::remove_cv<T>::type;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using iterator = /* implementation-defined */;
    // ...
};

void process(int* array, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        array[i] *= 2;
    }
}

void process(std::vector<int>& vec) {
    for (auto& val : vec) {
        val *= 2;
    }
}

void process(std::span<int> data) {
    for (auto& val : data) {
        val *= 2;
    }
}

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::span<int> span_numbers(numbers);
 
// Безопасный доступ с проверкой границ
try {
    int value = span_numbers.at(10); // Выбросит исключение
} catch (const std::out_of_range& e) {
    // Обработка исключения
}

void display(std::span<const int> data) {
    for (int val : data) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}
 
std::vector<int> mutable_data = {1, 2, 3};
std::span<const int> const_view(mutable_data);
 
// Следующая строка вызвала бы ошибку компиляции
// const_view[0] = 42;

std::span<int> createSpan() {
    std::vector<int> temp = {1, 2, 3};
    return std::span<int>(temp); // ОПАСНО! temp разрушается при выходе из функции
}

// Span с динамическим размером
std::span<int> dynamicSpan;
 
// Span с фиксированным размером (5 элементов)
std::span<int, 5> fixedSpan;

int arr[5] = {1, 2, 3, 4, 5};
std::span<int, 5> fixedSpan(arr);  // Правильно
// std::span<int, 10> wrongSpan(arr);  // Ошибка компиляции!

// Старый код
void oldFunction(int* data, size_t size) {
    // ...
}
 
// Адаптер для использования со span
void newFunction(std::span<int> data) {
    oldFunction(data.data(), data.size());
}

std::string s = "Hello, world!";
std::string_view sv(s);  // Невладеющее представление строки
std::span<const char> sp(s);  // Невладеющее представление последовательности символов

int matrix[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
std::span<std::span<int, 4>, 3> matrix_span(reinterpret_cast<std::span<int, 4>(&matrix[0])[0], 3);

std::span<int> dangerous() {
    std::vector<int> local = {1, 2, 3};
    return std::span<int>(local);  // local уничтожается при выходе из функции!
}

#include <span>
#include <vector>
#include <array>
#include <iostream>
 
int main() {
    // Создание span из C-массива
    int rawArray[] = {1, 2, 3, 4, 5};
    std::span<int> spanFromRawArray(rawArray);
    
    // Создание span из std::vector
    std::vector<int> vec = {10, 20, 30, 40, 50};
    std::span<int> spanFromVector(vec);
    
    // Создание span из std::array
    std::array<int, 3> arr = {100, 200, 300};
    std::span<int> spanFromArray(arr);
    
    // Доступ к элементам через span
    spanFromVector[0] = 15; // Изменение первого элемента вектора через span
    
    // Вывод элементов исходного вектора показывает, что изменения отражаются
    for (int num : vec) {
        std::cout << num << " ";
    }
    // Выведет: 15 20 30 40 50
    
    return 0;
}

int rawArray[] = {1, 2, 3, 4, 5};
std::span spanFromRawArray(rawArray); // Компилятор выведет std::span<int>

#include <span>
#include <vector>
#include <iostream>
 
void processFixedSpan(std::span<int, 3> fixed) {
    std::cout << "Обработка span с фиксированным размером: ";
    for (int value : fixed) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}
 
void processDynamicSpan(std::span<int> dynamic) {
    std::cout << "Обработка span с динамическим размером: ";
    for (int value : dynamic) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}
 
int main() {
    int array[3] = {1, 2, 3};
    std::vector<int> vec = {4, 5, 6, 7};
    
    // Span с фиксированным размером
    std::span<int, 3> fixedSpan(array);
    processFixedSpan(fixedSpan);
    
    // Span с динамическим размером
    std::span<int> dynamicSpan(vec);
    processDynamicSpan(dynamicSpan);
    
    // Этот код вызовет ошибку компиляции, так как размер не совпадает
    // processFixedSpan(dynamicSpan);
    
    return 0;
}

#include <span>
#include <vector>
#include <iostream>
 
void printSpan(std::span<const int> data, const std::string& label) {
    std::cout << label << ": ";
    for (int value : data) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}
 
int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50, 60, 70, 80};
    std::span<int> fullSpan(numbers);
    
    // Создание subspan, начиная с индекса 2, длиной 4 элемента
    auto middleSpan = fullSpan.subspan(2, 4);
    printSpan(middleSpan, "Средняя часть");  // Выведет: 30 40 50 60
    
    // Создание subspan, начиная с индекса 6 до конца
    auto endSpan = fullSpan.subspan(6);
    printSpan(endSpan, "Конец");  // Выведет: 70 80
    
    // Изменение элемента через subspan отражается в оригинальных данных
    middleSpan[1] = 45;
    printSpan(fullSpan, "После изменения");  // В элементе с индексом 3 будет 45
    
    return 0;
}

#include <span>
#include <vector>
#include <algorithm>
#include <numeric>
 
// Функция для нахождения среднего значения в окне данных
double computeMovingAverage(std::span<const double> data, size_t windowSize) {
    if (data.size() < windowSize || windowSize == 0) {
        return 0.0;
    }
    
    double sum = std::accumulate(data.begin(), data.begin() + windowSize, 0.0);
    return sum / windowSize;
}
 
// Функция для обработки всех данных с использованием скользящего окна
std::vector<double> processWithMovingAverage(std::span<const double> signal, size_t windowSize) {
    std::vector<double> result;
    result.reserve(signal.size() - windowSize + 1);
    
    for (size_t i = 0; i <= signal.size() - windowSize; ++i) {
        double average = computeMovingAverage(signal.subspan(i, windowSize), windowSize);
        result.push_back(average);
    }
    
    return result;
}

#include <span>
#include <vector>
#include <iostream>
 
// Функция для суммирования элементов в строке матрицы
int sumRow(std::span<const int> row) {
    int result = 0;
    for (int value : row) {
        result += value;
    }
    return result;
}
 
// Функция для работы с двумерной матрицей
void processMatrix(std::span<const int> matrix, int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        // Выделяем одну строку из линеаризованной матрицы
        auto row = matrix.subspan(i * cols, cols);
        std::cout << "Сумма элементов строки " << i << ": " << sumRow(row) << std::endl;
    }
}
 
int main() {
    // Создаем линеаризованную матрицу 3x3
    std::vector<int> matrix = {
        1, 2, 3,  // Строка 0
        4, 5, 6,  // Строка 1
        7, 8, 9   // Строка 2
    };
    
    processMatrix(matrix, 3, 3);
    
    return 0;
}

// Старый C-API
extern "C" {
    void process_data(const float* data, size_t count);
    int analyze_buffer(int* buffer, size_t size);
}
 
// Современный C++ код, использующий span
#include <span>
#include <vector>
 
void processSensorData(std::span<const float> sensorData) {
    // Вызов C-API с данными из span
    process_data(sensorData.data(), sensorData.size());
}
 
int analyzeAndUpdateValues(std::span<int> values) {
    // Вызов C-API, который может модифицировать данные
    return analyze_buffer(values.data(), values.size());
}

#include <span>
#include <vector>
#include <array>
#include <string>
 
void demonstrateSpanConversions() {
    // Создание из std::array
    std::array<double, 5> arr = {1.1, 2.2, 3.3, 4.4, 5.5};
    std::span<double, 5> spanFromArray(arr);  // Фиксированный размер
    std::span<double> dynamicSpanFromArray(arr);  // Динамический размер
    
    // Создание из std::vector
    std::vector<int> vec = {10, 20, 30};
    std::span<int> spanFromVector(vec);
    
    // Создание из std::string (как последовательности символов)
    std::string str = "Hello";
    std::span<const char> spanFromString(str);
    
    // Создание из подмножества std::vector
    if (vec.size() >= 2) {
        std::span<int> partialSpan(vec.data() + 1, 2);  // Элементы 20, 30
    }
    
    // Создание span для const-данных из неконстантных
    std::span<const int> constSpanFromVector(vec);
    
    // ПРИМЕЧАНИЕ: Следующий код не скомпилируется из-за нарушения const-корректности
    // std::vector<const int> constVec = {1, 2, 3}; // Вектор из const-элементов не допускается
    // std::span<int> nonConstSpanFromConst(constSpanFromVector); // Нарушение const-корректности
}

#include <span>
#include <iostream>
 
void processDoubleArray(std::span<double> data) {
    // Обработка массива double
}
 
int main() {
    // C-массив на стеке
    double stackArray[5] = {1.0, 2.0, 3.0, 4.0, 5.0};
    processDoubleArray(stackArray);  // OK
    
    // Динамически выделенный массив
    double* heapArray = new double[5]{6.0, 7.0, 8.0, 9.0, 10.0};
    
    // ВНИМАНИЕ: Следующий код требует явного указания размера,
    // так как для динамического массива компилятор не знает его размер
    // processDoubleArray(heapArray);  // Ошибка! Размер неизвестен
    
    // Правильный способ с явным указанием размера
    processDoubleArray(std::span<double>(heapArray, 5));
    
    delete[] heapArray;
    
    return 0;
}

#include <span>
#include <vector>
#include <iostream>
 
// Функция, которая только читает данные
void printData(std::span<const int> data) {
    for (const int value : data) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}
 
// Функция, которая модифицирует данные
void doubleValues(std::span<int> data) {
    for (int& value : data) {
        value *= 2;
    }
}
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // Используем const span для функции, которая только читает данные
    printData(numbers);
    
    // Используем неконстантный span для функции, которая модифицирует данные
    doubleValues(numbers);
    
    // Проверяем, что данные изменились
    printData(numbers);
    
    // Для константных контейнеров мы можем использовать только const span
    const std::vector<int> constNumbers = {6, 7, 8};
    printData(constNumbers);
    
    // Следующий код вызвал бы ошибку компиляции
    // doubleValues(constNumbers);
    
    return 0;
}

   void processVector(std::vector<int> vec) {
       // Полное копирование вектора
       for (auto& elem : vec) {
           elem *= 2;
       }
   }

   void processVectorRef(std::vector<int>& vec) {
       // Без копирования, но ограничено типом std::vector
       for (auto& elem : vec) {
           elem *= 2;
       }
   }

   void processArray(int* data, size_t size) {
       // Без копирования, но без безопасности типов
       for (size_t i = 0; i < size; ++i) {
           data[i] *= 2;
       }
   }

   void processSpan(std::span<int> data) {
       // Без копирования, с безопасностью типов и универсальностью
       for (auto& elem : data) {
           elem *= 2;
       }
   }

#include <span>
#include <vector>
#include <chrono>
#include <iostream>
 
// Функции для тестирования различных подходов
void sumWithVector(const std::vector<int>& vec) {
    volatile int sum = 0;
    for (int value : vec) {
        sum += value;
    }
}
 
void sumWithPointer(const int* data, size_t size) {
    volatile int sum = 0;
    for (size_t i = 0; i < size; ++i) {
        sum += data[i];
    }
}
 
void sumWithSpan(std::span<const int> data) {
    volatile int sum = 0;
    for (int value : data) {
        sum += value;
    }
}
 
int main() {
    const int iterations = 1000000;
    std::vector<int> testData(1000, 1);
    
    // Тест с std::vector
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        sumWithVector(testData);
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Vector: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms\n";
    
    // Тест с указателем
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        sumWithPointer(testData.data(), testData.size());
    }
    end = std::chrono::high_resolution_clock::now();
    std::cout << "Pointer: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms\n";
    
    // Тест со std::span
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        sumWithSpan(testData);
    }
    end = std::chrono::high_resolution_clock::now();
    std::cout << "Span: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms\n";
    
    return 0;
}

   std::span<int> createBadSpan() {
       std::vector<int> tempData = {1, 2, 3};
       return std::span<int>(tempData);  // tempData будет уничтожен!
   }
   
   void usageExample() {
       auto span = createBadSpan();  // span теперь указывает на недействительную память
       int value = span[0];  // Неопределенное поведение!
   }

   // Потенциальная проблема - создание span в цикле
   for (int i = 0; i < 1000000; ++i) {
       std::span<int> tempSpan(largeVector);
       // Обработка данных через tempSpan
   }
   
   // Лучший вариант - создание span за пределами цикла
   std::span<int> reusableSpan(largeVector);
   for (int i = 0; i < 1000000; ++i) {
       // Обработка данных через reusableSpan
   }

// Неэффективно: создание временного вектора и затем span
std::vector<int> createAndProcess() {
    std::vector<int> result = {1, 2, 3};
    std::span<int> resultSpan(result);  // Излишне
    processData(resultSpan);  // Можно просто передать result
    return result;
}
 
// Неэффективно: частое создание subspan во вложенных циклах
void processByBlocks(std::span<int> data, int blockSize) {
    for (size_t i = 0; i < data.size(); i += blockSize) {
        for (size_t j = 0; j < blockSize && i + j < data.size(); ++j) {
            auto element = data.subspan(i + j, 1);  // Создание subspan для одного элемента избыточно
            processElement(element[0]);  // Лучше использовать data[i + j]
        }
    }
}

#include <span>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iostream>
 
int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
    std::span<int> numbersSpan(numbers);
    
    // Сортировка через std::span
    std::sort(numbersSpan.begin(), numbersSpan.end());
    
    // Проверка, что все элементы отсортированы
    bool isSorted = std::is_sorted(numbersSpan.begin(), numbersSpan.end());
    std::cout << "Отсортировано: " << (isSorted ? "Да" : "Нет") << std::endl;
    
    // Подсчёт суммы элементов
    int sum = std::accumulate(numbersSpan.begin(), numbersSpan.end(), 0);
    std::cout << "Сумма: " << sum << std::endl;
    
    // Преобразование всех элементов (умножение на 2)
    std::transform(numbersSpan.begin(), numbersSpan.end(), numbersSpan.begin(),
                   [](int val) { return val * 2; });
    
    // Вывод преобразованных элементов
    for (int val : numbersSpan) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

#include <span>
#include <vector>
#include <iostream>
#include <algorithm>
 
// Функция для обработки блоков данных
void processDataBlocks(std::span<const int> data, size_t blockSize) {
    for (size_t offset = 0; offset < data.size(); offset += blockSize) {
        // Вычисляем размер текущего блока (может быть меньше blockSize в конце)
        size_t currentBlockSize = std::min(blockSize, data.size() - offset);
        
        // Создаём span для текущего блока
        auto block = data.subspan(offset, currentBlockSize);
        
        // Обрабатываем блок (например, находим максимальный элемент)
        auto maxElement = std::max_element(block.begin(), block.end());
        
        std::cout << "Блок начиная с индекса " << offset 
                  << ", максимальный элемент: " << *maxElement << std::endl;
    }
}
 
int main() {
    std::vector<int> data = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    
    // Обработка данных блоками по 3 элемента
    processDataBlocks(data, 3);
    
    return 0;
}

#include <span>
#include <vector>
#include <iostream>
 
// Функция для работы с матрицей через std::span
void printMatrix(std::span<const int> matrix, size_t rows, size_t cols) {
    for (size_t r = 0; r < rows; ++r) {
        for (size_t c = 0; c < cols; ++c) {
            std::cout << matrix[r * cols + c] << "\t";
        }
        std::cout << std::endl;
    }
}
 
// Функция для транспонирования матрицы
std::vector<int> transposeMatrix(std::span<const int> matrix, size_t rows, size_t cols) {
    std::vector<int> result(rows * cols);
    
    for (size_t r = 0; r < rows; ++r) {
        for (size_t c = 0; c < cols; ++c) {
            result[c * rows + r] = matrix[r * cols + c];
        }
    }
    
    return result;
}
 
int main() {
    // Создаём матрицу 3x3 в линейном представлении
    std::vector<int> matrixData = {
        1, 2, 3,
        4, 5, 6,
        7, 8, 9
    };
    
    std::cout << "Исходная матрица:" << std::endl;
    printMatrix(matrixData, 3, 3);
    
    auto transposed = transposeMatrix(matrixData, 3, 3);
    
    std::cout << "Транспонированная матрица:" << std::endl;
    printMatrix(transposed, 3, 3);
    
    return 0;
}

#include <span>
#include <vector>
#include <iostream>
 
class CircularBuffer {
private:
    std::vector<int> data;
    size_t head = 0;
    size_t size = 0;
    
public:
    explicit CircularBuffer(size_t capacity) : data(capacity) {}
    
    void push(int value) {
        size_t insertPos = (head + size) % data.size();
        data[insertPos] = value;
        
        if (size < data.size()) {
            ++size;
        } else {
            // Буфер полный, смещаем head
            head = (head + 1) % data.size();
        }
    }
    
    // Получаем span текущего содержимого буфера
    std::span<const int> getElements() const {
        if (size == 0) {
            return {};
        }
        
        if (head + size <= data.size()) {
            // Данные находятся в непрерывном блоке
            return std::span<const int>(data.data() + head, size);
        } else {
            // Данные "обернуты" вокруг конца вектора
            // В этом случае span не может охватить все элементы сразу
            // Возвращаем только часть от head до конца вектора
            return std::span<const int>(data.data() + head, data.size() - head);
        }
    }
    
    // Получаем span для второй части (если данные "обернуты")
    std::span<const int> getWrappedElements() const {
        if (size == 0 || head + size <= data.size()) {
            return {};
        }
        
        // Вычисляем, сколько элементов находится в начале вектора
        size_t wrappedCount = (head + size) % data.size();
        return std::span<const int>(data.data(), wrappedCount);
    }
};

#include <span>
#include <vector>
#include <iostream>
#include <algorithm>
 
// Функция для поиска подпоследовательности с максимальной суммой
std::span<const int> findMaxSumSubarray(std::span<const int> data) {
    if (data.empty()) {
        return {};
    }
    
    int maxSum = data[0];
    int currentSum = data[0];
    
    size_t maxStart = 0;
    size_t maxEnd = 1;
    size_t currentStart = 0;
    
    for (size_t i = 1; i < data.size(); ++i) {
        if (data[i] > currentSum + data[i]) {
            currentStart = i;
            currentSum = data[i];
        } else {
            currentSum += data[i];
        }
        
        if (currentSum > maxSum) {
            maxSum = currentSum;
            maxStart = currentStart;
            maxEnd = i + 1;
        }
    }
    
    return data.subspan(maxStart, maxEnd - maxStart);
}
 
int main() {
    std::vector<int> data = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
    
    auto maxSubarray = findMaxSumSubarray(data);
    
    std::cout << "Подпоследовательность с максимальной суммой: ";
    for (int val : maxSubarray) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    int sum = std::accumulate(maxSubarray.begin(), maxSubarray.end(), 0);
    std::cout << "Сумма: " << sum << std::endl;
    
    return 0;
}

#include <span>
#include <vector>
#include <thread>
#include <numeric>
#include <iostream>
#include <mutex>
 
std::mutex outputMutex;
 
// Функция для обработки части данных в отдельном потоке
void processDataChunk(std::span<const int> chunk, int threadId, std::vector<int>& results) {
    // Суммируем элементы в данном chunk
    int sum = std::accumulate(chunk.begin(), chunk.end(), 0);
    
    {
        std::lock_guard<std::mutex> lock(outputMutex);
        std::cout << "Поток " << threadId << " обработал " << chunk.size() 
                  << " элементов, сумма: " << sum << std::endl;
    }
    
    results[threadId] = sum;
}
 
int main() {
    const int dataSize = 1000000;
    const int numThreads = 4;
    
    // Создаём большой массив данных
    std::vector<int> data(dataSize, 1);  // Все элементы равны 1 для простоты
    
    // Вектор для хранения результатов от каждого потока
    std::vector<int> results(numThreads, 0);
    
    // Вектор потоков
    std::vector<std::thread> threads;
    
    // Размер chunk для каждого потока
    size_t chunkSize = dataSize / numThreads;
    
    // Создаём и запускаем потоки
    for (int i = 0; i < numThreads; ++i) {
        size_t start = i * chunkSize;
        size_t end = (i == numThreads - 1) ? dataSize : start + chunkSize;
        
        threads.emplace_back(processDataChunk, 
                            std::span<const int>(&data[start], end - start), 
                            i, std::ref(results));
    }
    
    // Ждём завершения всех потоков
    for (auto& thread : threads) {
        thread.join();
    }
    
    // Суммируем результаты от всех потоков
    int totalSum = std::accumulate(results.begin(), results.end(), 0);
    std::cout << "Общая сумма: " << totalSum << std::endl;
    
    return 0;
}