生成一个矩阵求逆的代码，不要求时间复杂度，元素均为整数，答案用整数或分数回答，C++代码

在C++中，你可以使用高斯-约旦消元法（也称为列主元消元法）来计算矩阵的逆，但这不是最直接或高效的方法，因为它的时间复杂度较高。这里我们展示一个基础的手动步骤，假设矩阵较小，并且可以直接通过行操作得到。对于大矩阵，建议使用数值库如Eigen或LLVM提供的`inverse`函数。

#include <iostream>
#include <vector>

// Function to swap two elements
void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

// Row operation function for Gaussian elimination
std::vector<int> row_op(std::vector<int>& matrix, int i, int j, int multiplier) {
    matrix[i] += multiplier * matrix[j];
    return matrix;
}

// Calculate the inverse of a small square matrix (up to 3x3)
std::vector<std::vector<int>> calculate_inverse(const std::vector<std::vector<int>>& matrix) {
    int n = matrix.size();
    if (n != n * matrix[0].size()) {
        throw std::invalid_argument("Matrix must be square.");
    }

    // Make a copy of the input matrix
    std::vector<std::vector<int>> inv_matrix(n, std::vector<int>(n));
    for (int i = 0; i < n; ++i) {
        inv_matrix[i][i] = 1;
    }

    // Perform Gauss-Jordan elimination
    for (int i = 0; i < n - 1; ++i) {
        // Find pivot element in the current column and swap rows if needed
        int max_row_idx = i;
        for (int j = i + 1; j < n; ++j) {
            if (abs(matrix[j][i]) > abs(matrix[max_row_idx][i])) {
                max_row_idx = j;
            }
        }
        swap(inv_matrix[i], inv_matrix[max_row_idx]);
        
        // Eliminate elements below the pivot
        for (int j = i + 1; j < n; ++j) {
            int factor = matrix[j][i] / matrix[i][i]; // Division may result in non-integers
            row_op(inv_matrix, j, i, factor);
        }
    }

    // Check for determinant zero, which indicates an ill-conditioned or singular matrix
    int det = 1;
    for (int i = 0; i < n; ++i) {
        det *= inv_matrix[i][i];
    }
    if (det == 0) {
        throw std::runtime_error("Inverse does not exist, matrix is singular.");
    }

    // Convert the matrix to the final form by dividing each entry by the determinant
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            inv_matrix[i][j] /= det;
        }
    }

    return inv_matrix;
}

int main() {
    std::vector<std::vector<int>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    try {
        std::vector<std::vector<int>> inv = calculate_inverse(matrix);
        // Print the inverse matrix
        for (const auto& row : inv) {
            for (int val : row) {
                std::cout << val << " ";
            }
            std::cout << "\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << '\n';
    }

    return 0;
}

请注意，这个实现仅适用于小规模的方阵，并且不会处理除数为零的情况。实际应用中，你应该使用更成熟的数值算法，如LU分解、QR分解或LU奇异值分解等。