编写C语言程序，输入整数n（2<=n<=10）、n阶方阵A，计算A的逆矩阵并输出。要求使用指针进行操作，矩阵存储采用动态内存分配，矩阵元素为double类型，最终结果四舍五入保留两位小数输出，矩阵不可逆则输出0。

您好！感谢您提出的问题。根据您的要求，我可以给您提供以下C语言程序：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double **malloc_matrix(int n);
void free_matrix(double **matrix, int n);
void input_matrix(double **matrix, int n);
void print_matrix(double **matrix, int n);
double **inverse_matrix(double **matrix, int n);

int main()
{
    int n;
    printf("请输入矩阵的阶数n（2<=n<=10）：");
    scanf("%d", &n);

    // 分配矩阵所需的内存空间
    double **matrix = malloc_matrix(n);

    // 输入矩阵
    printf("请输入%d阶方阵A：\n", n);
    input_matrix(matrix, n);

    // 计算逆矩阵并输出
    double **inverse_matrix_ = inverse_matrix(matrix, n);
    if (inverse_matrix_ == NULL)
    {
        printf("矩阵不可逆！\n");
    }
    else
    {
        printf("A的逆矩阵为：\n");
        print_matrix(inverse_matrix_, n);
    }

    // 释放矩阵占用的内存空间
    free_matrix(matrix, n);
    if (inverse_matrix_ != NULL)
    {
        free_matrix(inverse_matrix_, n);
    }

    return 0;
}

// 分配n x n的double类型矩阵空间
double **malloc_matrix(int n)
{
    double **matrix = (double **)malloc(n * sizeof(double *));
    for (int i = 0; i < n; i++)
    {
        matrix[i] = (double *)malloc(n * sizeof(double));
    }
    return matrix;
}

// 释放n x n的矩阵空间
void free_matrix(double **matrix, int n)
{
    for (int i = 0; i < n; i++)
    {
        free(matrix[i]);
    }
    free(matrix);
}

// 输入n x n的矩阵
void input_matrix(double **matrix, int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            scanf("%lf", &matrix[i][j]);
        }
    }
}

// 输出n x n的矩阵
void print_matrix(double **matrix, int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("%.2lf ", matrix[i][j]);
        }
        printf("\n");
    }
}

// 计算n x n矩阵的逆矩阵
double **inverse_matrix(double **matrix, int n)
{
    // 构造增广矩阵[A|I]
    double **augmented_matrix = malloc_matrix(n);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            augmented_matrix[i][j] = matrix[i][j];
        }
        for (int j = n; j < 2 * n; j++)
        {
            augmented_matrix[i][j] = (i == j - n) ? 1.0 : 0.0;
        }
    }

    // 执行初等行变换，将[A|I]变为[I|B]，B为A的逆矩阵
    for (int i = 0; i < n; i++)
    {
        // 找到主元
        double pivot = augmented_matrix[i][i];
        int max_row = i;
        for (int j = i + 1; j < n; j++)
        {
            if (fabs(augmented_matrix[j][i]) > fabs(pivot))
            {
                pivot = augmented_matrix[j][i];
                max_row = j;
            }
        }

        // 判断矩阵是否可逆
        if (fabs(pivot) < 1e-15)
        {
            free_matrix(augmented_matrix, n);
            return NULL;
        }

        // 交换行
        if (max_row != i)
        {
            double *temp = augmented_matrix[max_row];
            augmented_matrix[max_row] = augmented_matrix[i];
            augmented_matrix[i] = temp;
        }

        // 消元
        for (int j = i + 1; j < 2 * n; j++)
        {
            augmented_matrix[i][j] /= pivot;
        }
        for (int j = 0; j < n; j++)
        {
            if (j == i)
            {
                continue;
            }
            double multiplier = augmented_matrix[j][i];
            for (int k = i + 1; k < 2 * n; k++)
            {
                augmented_matrix[j][k] -= multiplier * augmented_matrix[i][k];
            }
        }
    }

    // 提取逆矩阵B
    double **inverse_matrix_ = malloc_matrix(n);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            inverse_matrix_[i][j] = augmented_matrix[i][j + n];
        }
    }

    // 释放增广矩阵占用的内存空间
    free_matrix(augmented_matrix, n);

    return inverse_matrix_;
}

在上面的程序中，我们首先定义了四个函数：

- `malloc_matrix`：分配n x n的double类型矩阵空间；
- `free_matrix`：释放n x n的矩阵空间；
- `input_matrix`：输入n x n的矩阵；
- `print_matrix`：输出n x n的矩阵。

然后，在主函数中，我们按照您的要求依次进行了以下操作：

- 输入矩阵阶数n；
- 分配n x n的动态内存空间；
- 输入n x n的矩阵；
- 计算逆矩阵并输出；
- 释放矩阵占用的内存空间。

在计算逆矩阵的过程中，我们采用初等行变换的方法，将增广矩阵[A|I]转化为[I|B]。如果矩阵不可逆，则返回NULL，否则返回B，即A的逆矩阵。

希望这个程序可以满足您的需求，如果您有任何疑问，欢迎继续咨询！