Как вернуть массив из функции?

        numbers[] = { 1,1,1,1,1 };
    int num() {
        numbers[] = { 1,2,3,4,5 };
        return numbers;
    }
 
    cout << num();

void qsort(left, right)
{
  thread(qsort, left, mid);
  thread(qsort, mid, right);
}

#include<iostream>
using namespace std;
 
 
void FillArray(int arr[], const int size)
{
    for (int i = 0; i < size; i++)
    {
        arr[i] = rand() % 10;
    }
}
 
void PrintArray(int arr[], const int size)
{
    for (int i = 0; i < size; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}
 
//Функция быстрой сортировки
void quickSort(int arr[], const int size, int left, int right)
{
    int pivot;
    int l_hold = left;
    int r_hold = right;
    pivot = arr[left];
 
    while ((arr[right] >= pivot) && (left < right))
    {
        right--;
    }
    if (left != right)
    {
        arr[left] = arr[right];
        left++;
    }
 
    while ((arr[left] <= pivot) && (left < right))
    {
        left++;
    }
    if (left != right)
    {
        arr[right] = arr[left];
        right--;
    }
    arr[left] = pivot;
    pivot = left;
    left = l_hold;
    right = r_hold;
 
    if (left < pivot)
    {
        quickSort(arr, size, left, pivot - 1);
    }
    if (right > pivot)
    {
        quickSort(arr, size, pivot + 1, right);
    }
 
}
 
 
//входная функция
void Quick_sort_2()
{
    setlocale(LC_ALL, "ru");
    const int SIZE = 12;
    int a[SIZE];
    FillArray(a, SIZE);
    PrintArray(a, SIZE);
 
    quickSort(a, SIZE, 0, SIZE - 1);
    PrintArray(a, SIZE);
    
    system("pause");
}

#include <iostream>
#include <ctime>
#include <future>
 
 
using namespace std;
 
 
// класс для определения времени выполнения кода
class SimpleTimer
{
public:
    SimpleTimer()
    {
        start = std::chrono::high_resolution_clock::now();
    }
 
    ~SimpleTimer()
    {
        end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<float> duration = end - start;
 
        cout << "DURATION " << duration.count() << " s" << endl;
    }
 
private:
    std::chrono::time_point<std::chrono::steady_clock> start, end;
 
};
 
 
int partition(int arr[], int low, int high)
{
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; ++j)
    {
        if (arr[j] < pivot)
        {
            ++i;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[++i], arr[high]);
    return i;
}
 
 
void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        int pi = partition(arr, low, high);
 
        // не параллельно
        //quickSort(arr, low, pi - 1);
        //quickSort(arr, pi + 1, high);
 
        // параллельно
        std::future<void> result1(std::async(quickSort, arr, low, pi - 1));
        std::future<void> result2(std::async(quickSort, arr, pi + 1, high));
    }
}
 
 
int main()
{
    SimpleTimer sT; // для определения затраченного времени    (если не нужно, то можно убрать)
    
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
 
    quickSort(arr, 0, 9);
    
    for (auto val : arr) std::cout << val << ' ';
    
    cout << endl;
}

void Dynamic_Array()
{
    setlocale(LC_ALL, "ru");
 
    int num; //размер массива
    cout << "Введите размер массива: ";
    cin >> num;
 
    int *d_arr = new int[num]; //выделение памяти для массива
    for (int i = 0; i < num; i++)
    {
        d_arr[i] = i;
        cout << d_arr[i] << ' ';
    }
    delete[] d_arr;
 
    system("pause");
}

st = GetTickCount();
bubbleSort( a, size );
en = GetTickCount();
 
printf( "%d ms\t", en-st );