Динамические массивы в C++ - создание и использование

int staticArray[100]; // Размер определен на этапе компиляции

// Выделение памяти для одиночного элемента
int* ptr = new int;
*ptr = 10; // Использование памяти
delete ptr; // Освобождение памяти
 
// Выделение памяти для массива
int* arr = new int[10];
arr[0] = 5; // Использование элемента массива
delete[] arr; // Освобождение памяти, выделенной для массива

// При работе с объектами классов
class MyClass {
public:
    MyClass() { std::cout << "Constructor called\n"; }
    ~MyClass() { std::cout << "Destructor called\n"; }
    // ... другие методы и поля
};
 
MyClass* objArray = new MyClass[5]; // Вызовется 5 конструкторов
delete[] objArray; // Вызовется 5 деструкторов

Куча до выделения памяти:
[                Свободная память                ]
 
После new int[5]:
[int[5]][              Свободная память          ]
 
После ещё одного new double[3]:
[int[5]][double[3]][       Свободная память      ]
 
После delete[] для первого массива:
[Свободно][double[3]][     Свободная память      ]

// С использованием new/delete
MyClass* obj1 = new MyClass(); // Вызывается конструктор
delete obj1; // Вызывается деструктор
 
// С использованием malloc/free
MyClass* obj2 = (MyClass*)malloc(sizeof(MyClass)); // Конструктор не вызывается
// Для вызова конструктора необходимо использовать размещающий new (placement new)
new (obj2) MyClass();
// Для вызова деструктора перед освобождением памяти
obj2->~MyClass();
free(obj2);

class DynamicArray {
private:
    int* data;
    size_t size;
public:
    DynamicArray(size_t s) : size(s) {
        data = new int[size];
    }
    ~DynamicArray() {
        delete[] data; // Автоматическое освобождение при уничтожении объекта
    }
    // ... методы для работы с массивом
};
 
void foo() {
    DynamicArray arr(100); // Выделение памяти
    // Использование arr
} // При выходе из функции память автоматически освобождается

Исходное состояние кучи:
[                Свободная память                ]
 
После различных выделений и освобождений:
[объект1][свободно][объект2][свободно][объект3][свободно]

class ObjectPool {
private:
    struct Block { Block* next; };
    Block* freeList;
    size_t blockSize;
    
public:
    ObjectPool(size_t size) : blockSize(size >= sizeof(Block) ? size : sizeof(Block)) {
        freeList = nullptr;
    }
    
    void* allocate() {
        if (freeList == nullptr) {
            // Выделяем новый блок, если нет свободных
            size_t allocSize = blockSize > sizeof(Block) ? blockSize : sizeof(Block);
            freeList = reinterpret_cast<Block*>(new char[allocSize]);
            freeList->next = nullptr;
        }
        
        Block* result = freeList;
        freeList = freeList->next;
        return result;
    }
    
    void deallocate(void* p) {
        if (p == nullptr) return;
        
        // Возвращаем блок в список свободных
        Block* block = reinterpret_cast<Block*>(p);
        block->next = freeList;
        freeList = block;
    }
    
    ~ObjectPool() {
        // Освобождаем всю память при уничтожении пула
        while (freeList) {
            Block* next = freeList->next;
            delete[] reinterpret_cast<char*>(freeList);
            freeList = next;
        }
    }
};

struct alignas(16) AlignedStruct {
    int data[4]; // 16 байт, выровненных по границе 16 байт
};
 
void* aligned_malloc(size_t size, size_t alignment) {
    void* p1; // исходный блок памяти
    void** p2; // выровненный указатель внутри блока
    
    // Выделяем блок с дополнительным пространством для выравнивания
    p1 = malloc(size + alignment - 1 + sizeof(void*));
    if (!p1) return nullptr;
    
    // Находим адрес для выровненного указателя
    p2 = (void**)(((size_t)(p1) + sizeof(void*) + alignment - 1) & ~(alignment - 1));
    
    // Запоминаем исходный указатель для правильного освобождения памяти
    p2[-1] = p1;
    
    return p2;
}
 
void aligned_free(void* p) {
    // Получаем оригинальный указатель и освобождаем память
    free(((void**)p)[-1]);
}

try {
    int* array = new int[1000000000]; // Попытка выделить очень большой массив
    // ... работа с массивом
    delete[] array;
} catch (const std::bad_alloc& e) {
    std::cerr << "Ошибка выделения памяти: " << e.what() << std::endl;
    // Обработка ошибки, например, использование меньшего массива
}

void outOfMemoryHandler() {
    std::cerr << "Критическая ошибка: нехватка памяти!" << std::endl;
    // Освобождаем некоторые ресурсы или завершаем программу
    std::abort();
}
 
int main() {
    std::set_new_handler(outOfMemoryHandler);
    
    // Теперь при нехватке памяти будет вызван наш обработчик
    int* array = new int[1000000000];
    // ...
}

// Создание динамического массива целых чисел
int size = 10;
int* dynamicArray = new int[size];
 
// Инициализация элементов массива
for (int i = 0; i < size; ++i) {
    dynamicArray[i] = i * 2;
}
 
// Использование массива
int sum = 0;
for (int i = 0; i < size; ++i) {
    sum += dynamicArray[i];
    std::cout << dynamicArray[i] << " ";
}
std::cout << "\nСумма элементов: " << sum << std::endl;
 
// Освобождение памяти
delete[] dynamicArray;

class DataPoint {
public:
    DataPoint() : value(0) { std::cout << "Объект создан\n"; }
    ~DataPoint() { std::cout << "Объект уничтожен\n"; }
    int value;
};
 
// Создание массива объектов
DataPoint* points = new DataPoint[5]; // Вызовется 5 конструкторов
 
// Работа с объектами
for (int i = 0; i < 5; ++i) {
    points[i].value = i * 10;
}
 
// Уничтожение массива
delete[] points; // Вызовется 5 деструкторов

// Создание двумерного массива размером rows×cols
int rows = 3, cols = 4;
int** matrix = new int*[rows]; // Массив указателей
 
for (int i = 0; i < rows; ++i) {
    matrix[i] = new int[cols]; // Выделение памяти для каждой строки
}
 
// Инициализация массива
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
        matrix[i][j] = i * cols + j;
    }
}
 
// Вывод массива
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
        std::cout << matrix[i][j] << "\t";
    }
    std::cout << std::endl;
}
 
// Освобождение памяти
for (int i = 0; i < rows; ++i) {
    delete[] matrix[i]; // Освобождение памяти каждой строки
}
delete[] matrix; // Освобождение массива указателей

int** jaggedArray = new int*[3];
jaggedArray[0] = new int[5];
jaggedArray[1] = new int[3];
jaggedArray[2] = new int[7];

int rows = 3, cols = 4;
// Выделение непрерывного блока памяти
int* continuous = new int[rows * cols];
 
// Доступ к элементам через арифметику указателей
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
        continuous[i * cols + j] = i * cols + j;
    }
}
 
// Вывод массива
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
        std::cout << continuous[i * cols + j] << "\t";
    }
    std::cout << std::endl;
}
 
// Освобождение памяти одним вызовом
delete[] continuous;

void leakyFunction() {
    int* array = new int[1000];
    // Использование массива
    // Забыли освободить память!
}

void fixedFunction() {
    std::unique_ptr<int[]> array(new int[1000]);
    // Память будет освобождена автоматически
}

int* array = new int[10];
delete array; // Неправильно! Должно быть delete[]

int* array = new int[10];
delete[] array; // Правильно

int* array = new int[10];
array[10] = 5; // Ошибка! Допустимые индексы: 0-9

std::vector<int> safeArray(10);
// safeArray.at(10) = 5; // Генерирует исключение std::out_of_range

int* array = new int[10];
delete[] array;
delete[] array; // Ошибка! Память уже освобождена

int* array = new int[10];
delete[] array;
array = nullptr; // Указываем, что указатель больше никуда не указывает
// delete[] array; // Теперь это безопасно (ничего не делает)

void riskyFunction() {
    int* array = new int[1000];
    // Код, который может выбросить исключение
    functionThatMayThrow();
    delete[] array; // Этот код не выполнится при исключении
}

void safeFunction() {
    std::unique_ptr<int[]> array(new int[1000]);
    // Даже если будет выброшено исключение, память освободится
    functionThatMayThrow();
}

// Изменение размера динамического массива
int* resizeArray(int* oldArray, int oldSize, int newSize) {
    // Создаём новый массив желаемого размера
    int* newArray = new int[newSize];
    
    // Определяем сколько элементов копировать
    int copySize = (oldSize < newSize) ? oldSize : newSize;
    
    // Копируем элементы из старого массива в новый
    for (int i = 0; i < copySize; ++i) {
        newArray[i] = oldArray[i];
    }
    
    // Инициализируем новые элементы (если массив увеличивается)
    for (int i = copySize; i < newSize; ++i) {
        newArray[i] = 0; // или другое значение по умолчанию
    }
    
    // Освобождаем память старого массива
    delete[] oldArray;
    
    // Возвращаем указатель на новый массив
    return newArray;
}

int* myArray = new int[5] {1, 2, 3, 4, 5};
int oldSize = 5;
int newSize = 10;
 
myArray = resizeArray(myArray, oldSize, newSize);
// Теперь myArray указывает на новый блок памяти размером 10 элементов
// где первые 5 элементов — копии исходных, а остальные инициализированы нулями

try {
    int* hugeArray = new int[std::numeric_limits<int>::max()]; // Очень большой массив
    // Код, который выполнится, если память выделена успешно
    delete[] hugeArray;
} catch (const std::bad_alloc& e) {
    std::cerr << "Не удалось выделить память: " << e.what() << std::endl;
    // Обработка ошибки, например, использование меньшего массива
}

class ComplexObject {
public:
    ComplexObject(int id) : id_(id) {
        data_ = new int[1000];
        // Заполнение данных
    }
    
    ComplexObject(const ComplexObject& other) : id_(other.id_) {
        data_ = new int[1000]; // Может выбросить исключение
        // Копирование данных
    }
    
    ~ComplexObject() {
        delete[] data_;
    }
    
private:
    int id_;
    int* data_;
};
 
try {
    ComplexObject* objectsArray = new ComplexObject[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    // Использование массива объектов
    delete[] objectsArray;
} catch (...) {
    // Обработка исключений
}

template <typename T>
T* resizeArraySafe(T* oldArray, size_t oldSize, size_t newSize) {
    std::unique_ptr<T[]> newArray(new T[newSize]);
    
    size_t copySize = std::min(oldSize, newSize);
    for (size_t i = 0; i < copySize; ++i) {
        // Используем перемещение вместо копирования, если возможно
        newArray[i] = std::move(oldArray[i]);
    }
    
    delete[] oldArray;
    return newArray.release();
}

int* resizeArrayFast(int* oldArray, int oldSize, int newSize) {
    int* newArray = new int[newSize];
    
    // Копирование с использованием memcpy
    size_t copySize = std::min(oldSize, newSize) * sizeof(int);
    memcpy(newArray, oldArray, copySize);
    
    // Инициализация новых элементов
    for (int i = oldSize; i < newSize; ++i) {
        newArray[i] = 0;
    }
    
    delete[] oldArray;
    return newArray;
}

class BigObject {
public:
    // Конструктор перемещения
    BigObject(BigObject&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }
    
    // Оператор присваивания с перемещением
    BigObject& operator=(BigObject&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }
    
private:
    int* data_;
    size_t size_;
};

// Предварительное выделение памяти с запасом
int estimatedSize = initialSize * 2;
int* array = new int[estimatedSize];
int actualSize = initialSize;
 
// Использование только части массива
for (int i = 0; i < actualSize; ++i) {
    // операции с array[i]
}
 
// Увеличение фактического размера без реаллокации,
// если ещё есть место в предварительно выделенном массиве
if (actualSize < estimatedSize) {
    actualSize++;
}

class Stack {
private:
    int* data;
    int capacity;
    int topIndex;
 
public:
    Stack(int initialCapacity = 10) : capacity(initialCapacity), topIndex(-1) {
        data = new int[capacity];
    }
 
    ~Stack() {
        delete[] data;
    }
 
    void push(int value) {
        if (topIndex == capacity - 1) {
            // Увеличиваем размер стека при заполнении
            int newCapacity = capacity * 2;
            int* newData = new int[newCapacity];
            
            for (int i = 0; i < capacity; ++i) {
                newData[i] = data[i];
            }
            
            delete[] data;
            data = newData;
            capacity = newCapacity;
        }
        
        data[++topIndex] = value;
    }
 
    int pop() {
        if (isEmpty()) {
            throw std::runtime_error("Стек пуст");
        }
        return data[topIndex--];
    }
 
    bool isEmpty() const {
        return topIndex == -1;
    }
};

class CircularQueue {
private:
    int* buffer;
    int capacity;
    int front;
    int rear;
    int count;
 
public:
    CircularQueue(int size = 10) : capacity(size), front(0), rear(0), count(0) {
        buffer = new int[capacity];
    }
 
    ~CircularQueue() {
        delete[] buffer;
    }
 
    void enqueue(int value) {
        if (isFull()) {
            // Увеличиваем размер при заполнении
            int newCapacity = capacity * 2;
            int* newBuffer = new int[newCapacity];
            
            // Копируем элементы с учётом кольцевой структуры
            for (int i = 0; i < count; ++i) {
                newBuffer[i] = buffer[(front + i) % capacity];
            }
            
            delete[] buffer;
            buffer = newBuffer;
            front = 0;
            rear = count;
            capacity = newCapacity;
        }
        
        buffer[rear] = value;
        rear = (rear + 1) % capacity;
        count++;
    }
 
    int dequeue() {
        if (isEmpty()) {
            throw std::runtime_error("Очередь пуста");
        }
        
        int value = buffer[front];
        front = (front + 1) % capacity;
        count--;
        return value;
    }
 
    bool isEmpty() const {
        return count == 0;
    }
 
    bool isFull() const {
        return count == capacity;
    }
};

template <typename T, size_t PoolSize>
class ObjectPool {
private:
    struct Node {
        char data[sizeof(T)];
        Node* next;
    };
    
    Node* freeList;
    Node  pool[PoolSize];
 
public:
    ObjectPool() {
        // Инициализируем список свободных блоков
        freeList = &pool[0];
        for (size_t i = 0; i < PoolSize - 1; ++i) {
            pool[i].next = &pool[i + 1];
        }
        pool[PoolSize - 1].next = nullptr;
    }
    
    T* allocate() {
        if (freeList == nullptr) {
            return nullptr; // Пул исчерпан
        }
        
        Node* node = freeList;
        freeList = freeList->next;
        
        return reinterpret_cast<T*>(node->data);
    }
    
    void deallocate(T* object) {
        if (object == nullptr) return;
        
        // Находим соответствующий узел Node
        Node* node = reinterpret_cast<Node*>(
            reinterpret_cast<char*>(object) - 
            offsetof(Node, data)
        );
        
        // Возвращаем в список свободных блоков
        node->next = freeList;
        freeList = node;
    }
};

class ResourceManager {
private:
    // Пул памяти
    char* memoryPool;
    size_t poolSize;
    std::mutex poolMutex; // Для многопоточного доступа
    
public:
    ResourceManager(size_t size) : poolSize(size) {
        memoryPool = new char[poolSize];
    }
    
    ~ResourceManager() {
        delete[] memoryPool;
    }
    
    // Кастомный deleter для умных указателей
    template <typename T>
    auto createPoolDeleter() {
        return [this](T* ptr) {
            std::lock_guard<std::mutex> lock(poolMutex);
            ptr->~T(); // Вызов деструктора
            // Здесь можно добавить логику возврата памяти в пул
        };
    }
    
    // Метод для создания объекта в пуле
    template <typename T, typename... Args>
    std::unique_ptr<T, decltype(createPoolDeleter<T>())> 
    createObject(Args&&... args) {
        std::lock_guard<std::mutex> lock(poolMutex);
        // Аллокация памяти из пула (упрощённо)
        T* object = new (memoryPool) T(std::forward<Args>(args)...);
        return std::unique_ptr<T, decltype(createPoolDeleter<T>())>(
            object, createPoolDeleter<T>());
    }
};

#include <vector>
 
// Создание вектора и добавление элементов
std::vector<int> numbers;
numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);
 
// Доступ к элементам
for (size_t i = 0; i < numbers.size(); ++i) {
    std::cout << numbers[i] << " ";
}
 
// Изменение размера
numbers.resize(10);  // Увеличивает размер до 10 элементов, 
                     // новые элементы инициализируются нулями
 
// Резервирование памяти для будущих элементов
numbers.reserve(20); // Выделяет память для 20 элементов без изменения размера
 
// Удаление элементов
numbers.pop_back();  // Удаляет последний элемент

// Демонстрация роста ёмкости вектора
std::vector<int> vec;
std::cout << "Initial capacity: " << vec.capacity() << std::endl;
 
for (int i = 0; i < 100; ++i) {
    vec.push_back(i);
    std::cout << "Added element " << i << ". New size: " << vec.size() 
              << ", capacity: " << vec.capacity() << std::endl;
}

// Двумерный вектор (аналог двумерного динамического массива)
std::vector<std::vector<int>> matrix(3, std::vector<int>(4, 0));
 
// Заполнение матрицы
for (size_t i = 0; i < matrix.size(); ++i) {
    for (size_t j = 0; j < matrix[i].size(); ++j) {
        matrix[i][j] = i * matrix[i].size() + j;
    }
}
 
// Неравномерная матрица ("зубчатый" массив)
std::vector<std::vector<int>> jaggedMatrix;
jaggedMatrix.push_back(std::vector<int>(5, 0));
jaggedMatrix.push_back(std::vector<int>(3, 0));
jaggedMatrix.push_back(std::vector<int>(7, 0));

// Тест производительности
#include <chrono>
#include <iostream>
#include <vector>
 
const int ITERATIONS = 100000000;
 
// Тест с динамическим массивом
void rawArrayTest() {
    auto start = std::chrono::high_resolution_clock::now();
    
    int* arr = new int[ITERATIONS];
    for (int i = 0; i < ITERATIONS; ++i) {
        arr[i] = i;
    }
    
    int sum = 0;
    for (int i = 0; i < ITERATIONS; ++i) {
        sum += arr[i];
    }
    
    delete[] arr;
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "Raw array time: " << diff.count() << " s\n";
}
 
// Тест с вектором
void vectorTest() {
    auto start = std::chrono::high_resolution_clock::now();
    
    std::vector<int> vec(ITERATIONS);
    for (int i = 0; i < ITERATIONS; ++i) {
        vec[i] = i;
    }
    
    int sum = 0;
    for (int i = 0; i < ITERATIONS; ++i) {
        sum += vec[i];
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "Vector time: " << diff.count() << " s\n";
}

#include <array>
 
std::array<int, 5> fixedArray = {1, 2, 3, 4, 5};

#include <deque>
 
std::deque<int> dq;
dq.push_back(10);    // Добавление в конец
dq.push_front(5);    // Добавление в начало (эффективнее, чем у вектора)

#include <list>
 
std::list<int> lst;
lst.push_back(10);
lst.push_front(5);
 
auto it = std::find(lst.begin(), lst.end(), 10);
lst.insert(it, 7);   // Вставка перед найденным элементом

// Пользовательский аллокатор для std::vector
template <typename T>
class PoolAllocator {
public:
    using value_type = T;
    
    PoolAllocator() = default;
    
    template <typename U>
    PoolAllocator(const PoolAllocator<U>&) {}
    
    T* allocate(std::size_t n) {
        // Здесь может быть реализация выделения памяти из пула
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    void deallocate(T* p, std::size_t n) {
        // Освобождение памяти
        ::operator delete(p);
    }
};
 
// Использование с вектором
std::vector<int, PoolAllocator<int>> poolVector;

// Пример использования std::unique_ptr для управления динамическим массивом
std::unique_ptr<int[]> smartArray(new int[10]);
for (int i = 0; i < 10; ++i) {
    smartArray[i] = i * 2;
}
// Память будет автоматически освобождена при выходе smartArray из области видимости

// Создание динамического массива через unique_ptr
std::unique_ptr<int[]> uniqueArr(new int[5]);
 
// Перемещение владения (но не копирование)
std::unique_ptr<int[]> newOwner = std::move(uniqueArr);
// Теперь uniqueArr == nullptr, а newOwner владеет массивом

// Для массивов лучше использовать custom deleter
std::shared_ptr<int> sharedArr(new int[5], [](int* p) { delete[] p; });
 
// Несколько указателей могут владеть одним ресурсом
std::shared_ptr<int> anotherPtr = sharedArr;

std::weak_ptr<int> weakPtr = sharedArr;
if (!weakPtr.expired()) {
    std::shared_ptr<int> lockedPtr = weakPtr.lock();
    // Используем объект, если он ещё существует
}

// Чтение из разных потоков (обычно безопасно)
void readThread(const std::vector<int>& vec, int threadId, int start, int end) {
    int sum = 0;
    for (int i = start; i < end; ++i) {
        sum += vec[i];
    }
    std::cout << "Thread " << threadId << " sum: " << sum << std::endl;
}

// Небезопасная запись из разных потоков
std::vector<int> vec(1000, 0);
 
void writeThread(std::vector<int>& vec, int threadId, int start, int end) {
    for (int i = start; i < end; ++i) {
        vec[i] = threadId; // Может привести к гонке данных
    }
}
 
// Безопасный вариант с использованием мьютекса
std::vector<int> vec(1000, 0);
std::mutex vecMutex;
 
void safeWriteThread(std::vector<int>& vec, int threadId, int start, int end) {
    for (int i = start; i < end; ++i) {
        std::lock_guard<std::mutex> lock(vecMutex);
        vec[i] = threadId; // Защищено мьютексом
    }
}

// Безопасное изменение размера
std::vector<int> vec;
std::mutex vecMutex;
 
void resizeThread() {
    std::lock_guard<std::mutex> lock(vecMutex);
    vec.resize(vec.size() + 100);
}

// Пример с атомарным счётчиком
std::atomic<int> counter(0);
 
void incrementThread() {
    for (int i = 0; i < 1000; ++i) {
        counter++; // Атомарная операция, безопасная между потоками
    }
}

// Прямое управление
int* array = new int[10];
delete[] array;
 
// Контейнер
std::vector<int> vec(10);

// Пример инструментации для отслеживания использования памяти
class MemoryTracker {
private:
    static size_t allocated;
    static size_t deallocated;
 
public:
    static void* trackAllocation(size_t size) {
        void* ptr = ::operator new(size);
        allocated += size;
        std::cout << "Allocated " << size << " bytes, total: " << allocated << std::endl;
        return ptr;
    }
 
    static void trackDeallocation(void* ptr, size_t size) {
        ::operator delete(ptr);
        deallocated += size;
        std::cout << "Deallocated " << size << " bytes, total: " << deallocated << std::endl;
    }
 
    static void report() {
        std::cout << "Memory report: allocated = " << allocated 
                  << ", deallocated = " << deallocated << std::endl;
    }
};
 
size_t MemoryTracker::allocated = 0;
size_t MemoryTracker::deallocated = 0;
 
// Использование инструментации
void* myAlloc(size_t size) {
    return MemoryTracker::trackAllocation(size);
}
 
void myFree(void* ptr, size_t size) {
    MemoryTracker::trackDeallocation(ptr, size);
}

// Предпочтительный способ для большинства задач
std::vector<int> numbers;
// Резервируем память заранее для повышения производительности
numbers.reserve(1000);
for (int i = 0; i < 1000; ++i) {
    numbers.push_back(i);
}

// Если нужен "голый" массив, используйте умные указатели
std::unique_ptr<int[]> rawData(new int[1000]);
// Память будет освобождена автоматически

// Вектор с кастомным аллокатором
std::vector<ComplexObject, CustomPoolAllocator<ComplexObject>> objects;
// Операции выделения/освобождения памяти будут происходить через аллокатор

void processData(std::span<int> data) {
    // Работа с диапазоном элементов без копирования
    for (int& value : data) {
        value *= 2;
    }
}
 
// Использование
std::vector<int> vec = {1, 2, 3, 4, 5};
processData(vec); // Автоматическое преобразование в span
 
int arr[] = {6, 7, 8, 9, 10};
processData(arr); // Работает и со статическими массивами