realiza un programa que resuelva un sistema de ecuaciones lineales con el metodo gauss-jordan. el programa debe preguntar si los coeficientes estan correctos el programa solo debe cerrarse cuando se slecciona la opcion salir y debe contener el siguiente menu,1)resolver sitemas, 2)salir.

Aquí te dejo el código en C++ que resuelve sistemas de ecuaciones lineales utilizando el método de Gauss-Jordan:

```c
#include <iostream>
#include <iomanip>

// Función para limpiar la matriz
void limpiarMatriz(double **a, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            a[i][j] = 0;
        }
    }
}

// Función para mostrar la matriz
void mostrarMatriz(double **a, int n) {
    std::cout << "Matriz actualizada:\n";
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            std::cout << std::setw(10) << a[i][j];
        }
        std::cout << "\n";
    }
    std::cout << std::endl;
}

// Función para convertir la matriz en triangular superior
void triangularSuperior(double **a, int n) {
    for (int i = 0; i < n; i++) {
        // Buscar el pivote en la columna i
        int pivot = i;
        for (int j = i + 1; j < n; j++) {
            if (std::abs(a[j][i]) > std::abs(a[pivot][i])) {
                pivot = j;
            }
        }
        if (a[pivot][i] == 0) {
            // Reemplazar la fila por otra con un elemento diferente a 0
            for (int j = i; j < n; j++) {
                if (a[i][j] != 0) {
                    for (int k = i; k < n + 1; k++) {
                        double aux = a[i][k];
                        a[i][k] = a[pivot][k];
                        a[pivot][k] = aux;
                    }
                    pivot = i;
                    break;
                }
            }
            // Si no se puede reemplazar la fila, el sistema no es determinado
            if (i != pivot) {
                System("system", "pause");
            }
        }
        // Reorganizar la matriz para que la fila i esté en el primer lugar de la diagonal
        for (int j = i; j < n; j++) {
            if (j != i) {
                double multiplicador = a[j][i] / a[i][i];
                for (int k = i; k < n + 1; k++) {
                    a[j][k] -= multiplicador * a[i][k];
                }
            }
        }
        // Invertir el signo de la fila i si el elemento en la diagonal es negativo
        if (a[i][i] < 0) {
            for (int j = i; j < n + 1; j++) {
                a[i][j] = -a[i][j];
            }
        }
        mostrarMatriz(a, n);
    }
}

// Función para realizar la factorización Gauss-Jordan
void gaussJordan(double **a, double *b, int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        triangularSuperior(a, n);
        // Reducir a 0 la columna i
        for (j = 0; j < n; j++) {
            if (j != i) {
                double multiplicador = a[j][i] / a[i][i];
                a[j][i] = 0;
                for (int k = i; k < n + 1; k++) {
                    a[j][k] -= multiplicador * a[i][k];
                }
                b[j] -= multiplicador * b[i];
            }
        }
        mostrarMatriz(a, n);
    }
}

//Función que imprime la solución del sistema de ecuaciones
void imprimirSolucion(double **a, double *b, int n){
    for (int i = 0; i < n; i++) {
        b[i] /= a[i][i];
        for (int j = i + 1; j < n; j++) {
            b[i] -= a[i][j] * b[j];
        }
        std::cout << "x_" << i + 1 << " = " << b[i] << "\n";
    }
}

// Función principal
int main() {
    int n, opc;
    double **a;
    double *b;
    std::cout << "Sistema de ecuaciones lineales\n";
    do {
        std::cout << "Menú:\n";
        std::cout << "1) Resolver sistema\n";
        std::cout << "2) Salir\n";
        std::cout << "Opción: ";
        std::cin >> opc;
        switch (opc) {
            case 1: {
                std::cout << "Ingrese el tamaño del sistema (n x n):\n";
                std::cin >> n;
                a = new double *[n];
                for (int i = 0; i < n; i++) {
                    a[i] = new double[n];
                }
                b = new double[n];
                limpiarMatriz(a, n);
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        std::cout << "Ingrese el elemento (" << i + 1 << "," << j + 1 << "): ";
                        std::cin >> a[i][j];
                    }
                }
                for (int i = 0; i < n; i++) {
                    std::cout << "Ingrese el elemento b_" << i + 1 << ": ";
                    std::cin >> b[i];
                }
                gaussJordan(a, b, n);
                imprimirSolucion(a, b,n);
                break;
            }
            case 2:
                break;
            default:
                std::cout << "Opción inválida\n";
                break;
        }
        if (opc != 2) {
            std::cout << "Presione Enter para continuar...\n";
            std::cin.ignore();
            std::cin.get();
        }
    } while (opc != 2);
    return 0;
}
```

Este programa presenta un menú con opciones para resolver sistemas de ecuaciones lineales utilizando el método de Gauss-Jordan o salir. Al seleccionar la opción de resolver sistema, el programa solicita la cantidad de ecuaciones y variables, y luego ingresa los coeficientes e incógnitas correspondientes. Después de realizar la factorización Gauss-Jordan, el programa imprime la solución del sistema de ecuaciones.