El usuario ingresa 5 valores a un arreglo A, y al final el programa mostrara el contenido del arreglo A, y un arreglo espejo con el contenido a la inversa, con variable temp. Ejem: A = 2 5 8 1 0 B = 0 1 8 5 2

Aquí te muestro un ejemplo de cómo podrías implementar esto en C++:

```cpp
#include <iostream>

// Función para leer 5 valores y almacenarlos en un arreglo
void leerValores(int arreglo[], int tam) {
    for (int i = 0; i < tam; i++) {
        std::cout << "Ingrese valor " << i + 1 << ": ";
        std::cin >> arreglo[i];
    }
}

// Función para mostrar el contenido de un arreglo
void mostrarArreglo(int arreglo[], int tam) {
    std::cout << "Arreglo A: ";
    for (int i = 0; i < tam; i++) {
        std::cout << arreglo[i] << " ";
    }
    std::cout << std::endl;
}

// Función para crear un arreglo espejo
void crearArregloEspejo(int arreglo[], int tam, int arregloEspejo[]) {
    for (int i = 0; i < tam; i++) {
        arregloEspejo[i] = arreglo[tam - i - 1];
    }
}

// Función para mostrar el contenido de un arreglo
void mostrarArregloEspejo(int arreglo[], int tam) {
    std::cout << "Arreglo B (espejo): ";
    for (int i = 0; i < tam; i++) {
        std::cout << arreglo[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    const int tam = 5;
    int arregloA[tam];
    int arregloB[tam];

    leerValores(arregloA, tam);
    mostrarArreglo(arregloA, tam);

    crearArregloEspejo(arregloA, tam, arregloB);
    mostrarArregloEspejo(arregloB, tam);

    return 0;
}
```

En este código, se definen cuatro funciones:

- `leerValores`: lee 5 valores y los almacena en un arreglo.
- `mostrarArreglo`: muestra el contenido de un arreglo.
- `crearArregloEspejo`: crea un arreglo espejo a partir de otro arreglo.
- `mostrarArregloEspejo`: muestra el contenido de un arreglo espejo.

En la función `main`, se llama a `leerValores` para leer los valores, luego se muestra el contenido del arreglo A. Luego, se llama a `crearArregloEspejo` para crear el arreglo B (espejo) y se muestra su contenido.

El arreglo B se crea a partir del arreglo A, invirtiendo el orden de los elementos. Por ejemplo, si el arreglo A es `[2, 5, 8, 1, 0]`, el arreglo B será `[0, 1, 8, 5, 2]`.