Функция возвращает массив

#include <iostream>
 
int* intArray(int n);
 
int main()
{
    const int n = 10;
    int* numbers = intArray(n);
    for (int i = 0; i < n; i++)
        std::cout << numbers[i] << " ";
    delete [] numbers;
    // продолжение кода
}
 
int* intArray(int n){
    int* int_array = new int [n];
    for (int i = 0; i < n; i++)
        int_array[i] = i + 1;
    return int_array;
}

#include <iostream>
#include <vector>
#include <numeric>
 
int main()
{
    std::vector<int> arr(10);
    std::iota(arr.begin(), arr.end(), 1);
    for(const auto & i : arr) std::cout << i << " ";
 
    return 0;
}

int* intArray(unsigned n)
{
  assert(n); // <--- защита от дебила
  int* int_array = new int[n];
  while (n--) int_array[n] = n + 1;
  return int_array;
}

#include <iostream>
 
int* intArray(int n);
 
int main()
{
    const int n = 10; // Или можно вводить с клавиши
    int* numbers = intArray(n);
    if (numbers)
    {
        for (int i = 0; i < n; i++)
            std::cout << numbers[i] << " ";
        delete[] numbers;
        numbers = NULL;
        // продолжение кода
    }
    
    return 0;
}
 
int* intArray(int n) 
{
    if (n < 1)
    {
        return nullptr;
    }
    else
    {
        int* int_array = new int[n];
        for (int i = 0; i < n; i++)
            int_array[i] = i + 1;
        return int_array;
    }
}

#include <iostream>
#include <vector>
#include <numeric>
 
std::vector<int> foo(size_t n)
{
    std::vector<int> arr(n);
    std::iota(arr.begin(), arr.end(), 1);
    return arr;
}
 
int main()
{
    auto arr = foo(12);
    for(const auto & i : arr) std::cout << i << " ";
 
    return 0;
}

std::iota(arr.begin(), arr.end(), 1);

#include <iostream>
#include <vector>
#include <numeric>
#include <chrono>
 
int* intArray(int n){
    int* int_array = new int[n];
    for(int i = 0; i < n; i++)
        int_array[i] = i + 1;
    return int_array;
}
 
void foo(size_t n)
{
    int* p = intArray(n);
    for(size_t i = 0; i < n; ++i)
        p[i] += 3;
 
    delete[] p;
}
 
void bar(std::vector<int> &arr, size_t n)
{
    arr.resize(n); //
    std::iota(arr.begin(), arr.end(), 1); //эт тут очень в лоб
 
    for(auto & i : arr)
        i += 3;
}
 
int main()
{
    srand(0);
    auto start_time = std::chrono::high_resolution_clock::now();
    for(size_t i = 0; i < 10000; ++i)
        foo(rand()%200);
    auto end_time = std::chrono::high_resolution_clock::now();
    std::cout << "dt: " << std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count() << "\n";
 
    srand(0);
    start_time = std::chrono::high_resolution_clock::now();
    std::vector<int> extarr;
    for(size_t i = 0; i < 10000; ++i)
        bar(extarr, rand()%200);
    end_time = std::chrono::high_resolution_clock::now();
    std::cout << "dt: " << std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count() << "\n";
 
    return 0;
}

#include <iostream>
 
///-----------------------------------------|
/// Ваша библа(my lib).                     |
///-----------------------------------------:
namespace ml
{
    template<class T>
    struct  Arr
    {       Arr(size_t N) : n(N) {   p = new T[n];}
           ~Arr(       )         {   delete[]  p ;}
 
        T& operator[](size_t i){   return *(p+i);}
        size_t  size (        ){   return   n   ;}
 
private:
        size_t n;
        T*     p;
    };
}; /// end ml
 
///-----------------------------------------|
/// Тест.                     
///-----------------------------------------:
int main()
{   ml::Arr<double> arr(10);
    for (size_t i = 0; i < arr.size(); i++)              arr[i] = 33.*i/10;
    for (size_t i = 0; i < arr.size(); i++) std::cout << arr[i] << ",  ";
}

const size_t& size (        ){ return   n   ;}