std::span в C++: Производительность и лучшие практики

// Старый подход с указателями - небезопасный, легко допустить ошибку
void processData(int* data, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // Обработка данных
    }
}
 
// Подход с использованием std::span - безопасный и элегантный
void processData(std::span<int> data) {
    for (auto& item : data) {
        // Обработка данных
    }
}

// Примерная внутренняя реализация std::span
template <class T>
class span {
private:
    T* ptr_;            // Указатель на начало данных
    size_t size_;       // Количество элементов
    
public:
    // Методы класса...
};

// Подход 1: Сырые указатели с размером
void process1(int* data, size_t size) {
    // Обработка данных
}
 
// Подход 2: Ссылка на std::vector
void process2(const std::vector<int>& vec) {
    // Обработка данных
}
 
// Подход 3: std::span
void process3(std::span<int> data) {
    // Обработка данных
}

// С копированием данных
std::vector<int> extractSubset(const std::vector<int>& vec, size_t start, size_t count) {
    std::vector<int> result(count);
    for (size_t i = 0; i < count; ++i) {
        result[i] = vec[start + i];
    }
    return result;
}
 
// Без копирования с использованием std::span
std::span<const int> viewSubset(const std::vector<int>& vec, size_t start, size_t count) {
    return std::span<const int>(vec.data() + start, count);
}

// Этот код...
for (int value : mySpan) {
    processValue(value);
}
 
// ...после оптимизации компилятора превращается примерно в это:
for (size_t i = 0; i < size; ++i) {
    processValue(data[i]);
}

std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> sp(vec);
 
// Использование алгоритмов STL со std::span
std::transform(sp.begin(), sp.end(), sp.begin(), [](int x) { return x * 2; });

std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> sp(vec);
 
// В оптимизированном коде эта проверка может быть устранена компилятором
for (size_t i = 0; i < sp.size(); ++i) {
    sp[i] *= 2;
}

// Пример кода для бенчмарка
constexpr size_t iterations = 1000000;
constexpr size_t arraySize = 1024;
 
// Тест со std::span
std::array<int, arraySize> arr;
std::span<int> sp(arr);
auto start = std::chrono::high_resolution_clock::now();
for (size_t iter = 0; iter < iterations; ++iter) {
    for (size_t i = 0; i < sp.size(); ++i) {
        sp[i] = static_cast<int>(i * iter);
    }
}
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> span_time = end - start;

// Пример использования в системе реального времени
void processSignalBuffer(std::span<const float> buffer) {
    float sum = 0.0f;
    // Быстрая, предсказуемая обработка с константным потреблением памяти
    for (float sample : buffer) {
        sum += std::abs(sample);
    }
    if (sum > threshold) {
        triggerAlert();
    }
}

// До рефакторинга
void processImage(const std::vector<uint8_t>& pixels, int width, int height) {
    // Обработка изображения
}
 
// После рефакторинга
void processImage(std::span<const uint8_t> pixels, int width, int height) {
    // Обработка изображения
}

std::vector<float> signalData(1000);
// Заполняем данные...
 
// Выделяем первые 100 элементов для анализа
std::span<float> header(signalData.data(), 100);
analyzePreamble(header);
 
// Выделяем следующие 900 элементов для обработки
std::span<float> payload(signalData.data() + 100, 900);
processPayload(payload);

// Запутанный API без std::span
class SignalProcessor {
public:
    void process(const int* data, size_t size);
    void process(const std::vector<int>& data);
    void process(const std::array<int, N>& data);  // Для каждого размера N
};
 
// Элегантный API со std::span
class SignalProcessor {
public:
    void process(std::span<const int> data);  // Работает со всеми вариантами выше
};

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::span<int> view(numbers);
 
// Находим первый чётный элемент
auto it = std::find_if(view.begin(), view.end(), [](int n) { return n % 2 == 0; });
 
// Сортируем только часть последовательности
auto subview = view.subspan(3, 5);  // элементы с индексами 3, 4, 5, 6, 7
std::sort(subview.begin(), subview.end());
 
// Подсчитываем сумму всех элементов
int sum = std::accumulate(view.begin(), view.end(), 0);

// Старый код с потенциальными проблемами
void analyzeSamples(double* samples, int count) {
    for (int i = 0; i < count; ++i) {
        // Анализ данных
        samples[i] = transformSample(samples[i]);
    }
}

// Современная версия с той же производительностью
void analyzeSamples(std::span<double> samples) {
    for (auto& sample : samples) {
        // Анализ данных
        sample = transformSample(sample);
    }
}

// В заголовочном файле
void processAudioBuffer(std::span<float> buffer);

// Двумерная матрица как набор строк
std::vector<float> matrixData(rows * cols);
std::span<float> matrix(matrixData);
 
// Доступ к элементам по координатам
auto at = [cols](std::span<float> m, size_t row, size_t col) -> float& {
    return m[row * cols + col];
};
 
// Получение строки матрицы
auto getRow = [cols](std::span<float> m, size_t row) -> std::span<float> {
    return std::span<float>(m.data() + row * cols, cols);
};
 
// Использование
std::span<float> thirdRow = getRow(matrix, 2);
float element = at(matrix, 1, 3);  // Элемент в строке 1, столбце 3

// Внешняя библиотека с C-интерфейсом
extern "C" {
    void process_audio_data(float* data, size_t samples);
}
 
// Наша C++ функция, использующая std::span
void enhanceAudio(std::span<float> audio) {
    // Предобработка
    applyFilter(audio);
    
    // Вызов внешней функции
    process_audio_data(audio.data(), audio.size());
    
    // Постобработка
    normalizeAudio(audio);
}

void processPacket(std::span<const uint8_t> packet) {
    // Первые 4 байта - заголовок
    std::span<const uint8_t> header = packet.subspan(0, 4);
    
    // Следующие N байт - текстовые данные
    size_t textLength = decodeLength(header);
    std::span<const char> textData(
        reinterpret_cast<const char*>(packet.data() + 4),
        textLength
    );
    
    // Обработка текста
    processText(textData);
}

std::vector<double> sharedData(10000);
std::mutex dataMutex;
 
void processDataChunk(std::span<double> chunk) {
    // Безопасная обработка своего куска данных без блокировок
    for (auto& value : chunk) {
        value = std::sqrt(value) + 5.0;
    }
}
 
void parallelProcess() {
    std::vector<std::thread> threads;
    const size_t chunks = 10;
    const size_t chunkSize = sharedData.size() / chunks;
    
    {
        // Блокируем только во время разделения данных
        std::lock_guard<std::mutex> lock(dataMutex);
        
        for (size_t i = 0; i < chunks; ++i) {
            size_t start = i * chunkSize;
            std::span<double> chunk(sharedData.data() + start, chunkSize);
            threads.emplace_back(processDataChunk, chunk);
        }
    }
    
    for (auto& t : threads) {
        t.join();
    }
}

// До оптимизации
void processLargeMatrix(const BigMatrix& matrix) {
    // Код обработки
}
 
// После оптимизации
void processLargeMatrix(std::span<const BigMatrixElement> elements, size_t rows, size_t cols) {
    // Более эффективный код обработки
}

// Гипотетический нестандартный контейнер
class CustomBuffer {
public:
    float* getRawData() { return data_; }
    size_t getElementCount() const { return size_; }
private:
    float* data_;
    size_t size_;
    // Другие детали реализации
};
 
// Адаптер для работы с STL-алгоритмами
std::span<float> getSpanView(CustomBuffer& buffer) {
    return std::span<float>(buffer.getRawData(), buffer.getElementCount());
}
 
// Использование
void processCustomBuffer(CustomBuffer& buffer) {
    auto view = getSpanView(buffer);
    std::sort(view.begin(), view.end());
    auto maxElement = std::max_element(view.begin(), view.end());
}

// Обобщённая функция обработки последовательностей любого типа
template<typename T>
auto processSequence(std::span<T> data) {
    using ResultType = std::decay_t<decltype(processElement(std::declval<T>()))>;
    
    std::vector<ResultType> results;
    results.reserve(data.size());
    
    for (const auto& item : data) {
        results.push_back(processElement(item));
    }
    
    return results;
}
 
// Использование с разными типами данных
std::vector<int> intData = {1, 2, 3, 4};
std::array<double, 3> doubleData = {1.1, 2.2, 3.3};
 
auto intResults = processSequence(intData);
auto doubleResults = processSequence(doubleData);

struct Vertex {
    float x, y, z;
    float nx, ny, nz;
    float u, v;
};
 
std::vector<Vertex> mesh;
 
// Получаем доступ только к координатам вершин
std::span<const float> getPositions(std::span<const Vertex> vertices) {
    return std::span<const float>(
        reinterpret_cast<const float*>(vertices.data()),
        vertices.size() * 3
    );
}
 
// Получаем доступ только к текстурным координатам
std::span<const float> getTexCoords(std::span<const Vertex> vertices) {
    return std::span<const float>(
        reinterpret_cast<const float*>(&vertices[0].u),
        vertices.size() * 2
    );
}
 
// Использование
void renderMesh(const std::vector<Vertex>& mesh) {
    auto positions = getPositions(mesh);
    auto texCoords = getTexCoords(mesh);
    
    uploadToGPU(positions, texCoords);
}

// До перехода на std::span
namespace MyLib {
    class Analyzer {
    public:
        Result analyze(const std::vector<Sample>& samples);
        void calibrate(const std::vector<float>& calibrationData);
    };
}
 
// После перехода на std::span
namespace MyLib {
    class Analyzer {
    public:
        Result analyze(std::span<const Sample> samples);
        void calibrate(std::span<const float> calibrationData);
    };
}

// Безопасное создание подпредставления с проверкой границ
std::optional<std::span<int>> safeSubspan(std::span<int> data, size_t offset, size_t count) {
    if (offset + count > data.size()) {
        return std::nullopt;  // Возвращаем пустой optional при выходе за границы
    }
    return data.subspan(offset, count);
}
 
// Использование
void processSubset(std::span<int> data, size_t offset, size_t count) {
    auto subset = safeSubspan(data, offset, count);
    if (!subset) {
        handleError("Invalid range specified");
        return;
    }
    
    // Безопасная обработка данных
    for (int& value : *subset) {
        // ...
    }
}

// Небезопасный подход - возвращает span на локальные данные!
std::span<int> BAD_getTemporaryData() {
    std::vector<int> localData = {1, 2, 3}; // ❌ Будет уничтожен при выходе из функции
    return std::span<int>(localData);
}
 
// Правильный подход с владельцем данных
class DataProvider {
private:
    std::vector<int> storedData_;
    
public:
    // Возвращает представление хранимых данных
    std::span<const int> getData() const {
        return storedData_;
    }
    
    // Возвращает изменяемое представление
    std::span<int> getDataMutable() {
        return storedData_;
    }
};

std::list<int> myList = {1, 2, 3, 4, 5};
// Этот код не скомпилируется, поскольку std::list не имеет непрерывной памяти
// std::span<int> listSpan(myList);
 
std::map<int, float> myMap;
// То же самое для map и других ассоциативных контейнеров
// std::span<std::pair<const int, float>> mapSpan(myMap);

std::span<int> createDanglingSpan() {
    std::vector<int> localVector = {1, 2, 3, 4, 5};
    return std::span<int>(localVector);  // ОПАСНО! localVector уничтожается при выходе из функции
}
 
void useSpan() {
    auto span = createDanglingSpan();
    // Использование span здесь приведёт к неопределённому поведению
    std::cout << span[0] << "\n";  // Катастрофа!
}

void processData(std::span<const int> data) {
    // Обработка данных
}
 
void potentiallyDangerousCode() {
    // Временный вектор, который будет уничтожен после вызова processData
    processData(std::vector<int>{1, 2, 3, 4, 5});  // ОПАСНО!
}

// Типичная ситуация при отладке проблем со std::span
void debugNightmare() {
    std::vector<int> data = {1, 2, 3};
    std::span<int> span(data);
    
    data.push_back(4);  // Потенциально инвалидирует span, если произошло перевыделение
    
    // Здесь span может указывать на действительную, но неактуальную память
    // Или может указывать на освобождённую память
    // И отладчик может не показать, что что-то не так
    std::cout << span[0] << "\n";
}

// Legacy API
void legacyProcess(int* data, int size) {
    // Может модифицировать данные неожиданным образом
    // Или изменить указатель
    data[0] = 42;
}
 
void modernCode() {
    std::vector<int> vec = {1, 2, 3};
    std::span<int> span(vec);
    
    // Потенциально опасный вызов
    legacyProcess(span.data(), static_cast<int>(span.size()));
    
    // После вызова span может быть в неопределённом состоянии,
    // если legacyProcess изменила размер или расположение данных
}

std::vector<int> data = {1, 2, 3};
std::span<int> span(data);
 
// При push_back может произойти перевыделение памяти,
// что сделает span недействительным
data.push_back(4);
data.push_back(5);
 
// Доступ к span теперь может привести к неопределённому поведению
for (int value : span) {
    std::cout << value << " ";  // Опасно!
}

// Предположим, библиотека XYZ ожидает специфический формат
namespace XYZ {
struct Buffer {
    void* data;
    size_t size;
};
 
void processBuffer(Buffer buffer);
}
 
// Преобразование span в формат библиотеки
void workWithExternalLibrary(std::span<uint8_t> data) {
    XYZ::Buffer buffer{data.data(), data.size()};
    XYZ::processBuffer(buffer);
    
    // Если библиотека изменила размер или указатель,
    // span останется неизменным и может стать некорректным
}

// Для асинхронных операций: использование std::shared_ptr
void asyncOperation(std::shared_ptr<std::vector<int>> data) {
auto future = std::async(std::launch::async, [data]() {
    // data гарантированно существует во время выполнения
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return std::accumulate(data->begin(), data->end(), 0);
});
}
 
// Использование:
auto vec = std::make_shared<std::vector<int>>(100, 42);
asyncOperation(vec);

void processReadOnly(std::span<const int> data) {
// Только чтение данных
}
 
void processReadWrite(std::span<int> data) {
// Чтение и запись данных
}
 
void sneakyModification() {
const std::vector<int> constVec = {1, 2, 3};
std::span<const int> constSpan(constVec);
    
// Это корректно - мы не можем модифицировать константные данные
processReadOnly(constSpan);
    
// Error: нельзя преобразовать const в не-const
// processReadWrite(constSpan);  // ❌ Компилятор не допустит
    
// Но что, если мы попытаемся обойти систему типов?
// Опасное и неправильное преобразование
std::span<int> mutableSpan(const_cast<int*>(constSpan.data()), constSpan.size());  // ❌ Технически компилируется, но ведет к UB
processReadWrite(mutableSpan);  // Нарушение константности!
}

void debugOverhead() {
std::vector<int> data(1000000, 42);
    
// В Debug режиме этот цикл может быть заметно медленнее
// из-за проверок границ при каждом обращении к span[i]
std::span<int> span(data);
for (size_t i = 0; i < span.size(); ++i) {
    span[i] = span[i] * 2;
}
}

void alignmentIssues() {
std::vector<char> buffer(1024);
std::span<char> bufferSpan(buffer);
    
// Преобразование в тип, требующий выравнивания
auto intPtr = reinterpret_cast<int*>(bufferSpan.data() + 1);  // +1 нарушает выравнивание для int
    
// На некоторых архитектурах это вызовет ошибку выравнивания
*intPtr = 42;  // Потенциально опасная операция!
}

// Span со статическим размером
std::span<int, 3> staticSpan;  // Всегда ровно 3 элемента
 
// Span с динамическим размером (по умолчанию)
std::span<int> dynamicSpan;
 
void sizeTypeIssues() {
std::array<int, 3> arr = {1, 2, 3};
std::vector<int> vec = {1, 2, 3, 4};
    
// Работает нормально
staticSpan = std::span<int, 3>(arr);
    
// Ошибка компиляции: неправильный размер
// staticSpan = std::span<int, 3>(vec);  // ❌ vec имеет 4 элемента
    
// Но что, если размер известен только во время выполнения?
if (vec.size() == 3) {
    // Всё равно нельзя без явного обрезания:
    // staticSpan = std::span<int, 3>(vec.data(), 3);  // Опасно!
}
}

void securityVulnerabilities() {
// Предположим, эта функция получает данные из ненадёжного источника
void fetchExternalData(std::span<char> buffer);
    
std::vector<char> secureBuffer(1024);
std::span<char> bufferView(secureBuffer);
    
// Внешний код может записать за пределы буфера
fetchExternalData(bufferView);
    
// Если fetchExternalData злонамеренно записала за пределы размера span,
// но внутри выделенной памяти вектора, стандартные проверки могут не обнаружить проблему
}

// Потенциальные проблемы совместимости
#if __cplusplus >= 202002L
// C++20 и новее
#include <span>
using ByteView = std::span<const uint8_t>;
#else
// До C++20
#include <vector>
class ByteView {
private:
    const uint8_t* data_;
    size_t size_;
public:
    ByteView(const uint8_t* d, size_t s) : data_(d), size_(s) {}
    ByteView(const std::vector<uint8_t>& vec) : data_(vec.data()), size_(vec.size()) {}
    // Реализовать минимальный интерфейс, схожий со std::span
};
#endif

std::span<int> createSpanFromTemporary() {
// В идеале компилятор должен предупредить, но не все компиляторы это делают
return std::vector<int>{1, 2, 3};  // Опасное возвращение span временного объекта
}
 
void limitedLifetimeChecking() {
auto span = createSpanFromTemporary();  // Опасно!
// Использование span здесь -> неопределённое поведение
}