¿Cómo devolver una array local desde una función C/C++?

Considere el siguiente programa en C++. ¿Es la forma correcta de devolver una array de una función?
 

#include <stdio.h>
 
int* fun()
{
    int arr[100];
 
    /* Some operations on arr[] */
    arr[0] = 10;
    arr[1] = 20;
 
    return arr;
}
 
int main()
{
    int* ptr = fun();
    printf("%d %d", ptr[0], ptr[1]);
    return 0;
}

#include <iostream>
using namespace std;
 
int* fun()
{
    int arr[100];
 
    /* Some operations on arr[] */
    arr[0] = 10;
    arr[1] = 20;
 
    return arr;
}
 
int main()
{
    int* ptr = fun();
    cout << ptr[0] << " " << ptr[1];
    return 0;
}

Advertencia: 
 

In function 'int* fun()':
6:8: warning: address of local variable 'arr' returned [-Wreturn-local-addr]
    int arr[100];
        ^

10 20

El programa anterior es INCORRECTO . Puede producir valores 10 20 como salida o puede producir valores basura o puede fallar. El problema es que devolvemos la dirección de una variable local que no se recomienda ya que las variables locales pueden no existir en la memoria después de que finaliza la llamada a la función .
Entonces, en palabras simples, las funciones no pueden devolver arrays en C. Sin embargo, para devolver la array en C mediante una función, se puede usar una de las siguientes alternativas. 
Las siguientes son algunas formas correctas de devolver una array:
 

Uso de array 
asignada dinámicamente: la memoria asignada dinámicamente (asignada usando new o malloc()) permanece hasta que la eliminemos usando delete o free(). Entonces podemos crear una array asignada dinámicamente y podemos eliminarla una vez que salgamos de la función.
 

#include <stdio.h>
 
int* fun(int *arr)
{
    /* Some operations on arr[] */
    arr[0] = 10;
    arr[1] = 20;
 
    return arr;
}
 
int main()
{
    int arr[100];
    int* ptr = fun(arr);
    printf("%d %d", ptr[0], ptr[1]);
    return 0;
}

#include <iostream>
using namespace std;
 
int* fun()
{
    int* arr = new int[100];
 
    /* Some operations on arr[] */
    arr[0] = 10;
    arr[1] = 20;
 
    return arr;
}
 
int main()
{
    int* ptr = fun();
    cout << ptr[0] << " " << ptr[1];
    delete[] ptr; //allocated memory must be deleted
    return 0;
}

10 20

Uso de array estática: 
la vida útil de una variable estática es a lo largo del programa. Entonces, siempre podemos crear una array estática local y devolverla.
 

#include <stdio.h>
 
int* fun()
{
    static int arr[100];
 
    /* Some operations on arr[] */
    arr[0] = 10;
    arr[1] = 20;
 
    return arr;
}
 
int main()
{
    int* ptr = fun();
    printf("%d %d", ptr[0], ptr[1]);
    return 0;
}

#include <iostream>
using namespace std;
 
int* fun()
{
    static int arr[100];
 
    /* Some operations on arr[] */
    arr[0] = 10;
    arr[1] = 20;
 
    return arr;
}
 
int main()
{
    int* ptr = fun();
    cout << ptr[0] << " " << ptr[1];
    return 0;
}

10 20

Usando struct: 
podemos envolver una array en una estructura/clase y devolver una instancia de la estructura/clase. La razón de este trabajo es que los miembros de la array de las estructuras se copian profundamente. En el programa a continuación, la copia profunda ocurre cuando devolvimos la instancia que se copia en main.
 

#include <stdio.h>
 
struct arrWrap {
    int arr[100];
};
 
struct arrWrap fun()
{
    struct arrWrap x;
 
    x.arr[0] = 10;
    x.arr[1] = 20;
 
    return x;
}
 
int main()
{
    struct arrWrap x = fun();
    printf("%d %d", x.arr[0], x.arr[1]);
    return 0;
}

#include <iostream>
using namespace std;
 
struct arrWrap {
    int arr[100];
};
 
struct arrWrap fun()
{
    struct arrWrap x;
 
    x.arr[0] = 10;
    x.arr[1] = 20;
 
    return x;
}
 
int main()
{
    struct arrWrap x = fun();
    cout << x.arr[0] << " " << x.arr[1];
    return 0;
}

10 20