c语言特殊矩阵怎么实现加减，存取，基本运算呀？

求解，特殊矩阵的加减，读取，转置，可以的话帮我写完功能，只需要对称矩阵的，真的非常非常感谢

#include <stdio.h>
void menu()
{
    printf("****************************************************************\n");
    printf("****************************************************************\n");
    printf("**********************欢迎使用矩阵计算器************************\n");
    printf("              1.转置2.加法3.减法4.数乘5.乘法0.退出              \n");
    printf("****************************************************************\n");
    printf("****************************************************************\n");
    printf("****************************************************************\n");
}

void  Matrix_output(int(*s)[100], int m, int n)//输出
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("%2d ", s[i][j]);
        }
        printf("\n");
    }
}

void  Matrix_transpose(int(*s)[100], int(*t)[100], int m, int n)//转置
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            t[j][i] = s[i][j];
        }
    }
}
void Matrix_addition(int(*s)[100], int(*t)[100], int(*p)[100], int m, int n)//相加
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            p[i][j] = s[i][j] + t[i][j];
        }
    }
}

void Matrix_subtraction(int(*s)[100], int(*t)[100], int(*p)[100], int m, int n)//相减
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            p[i][j] = s[i][j] - t[i][j];
        }
    }
}

void Matrix_shucheng(int(*s)[100], int(*t)[100], int m, int n, int k)//数乘
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            t[i][j] = k * s[i][j];
        }
    }
}

void Matrix_multiplication(int(*s)[100], int(*t)[100], int(*p)[100], int m, int n, int x, int y)//相乘
{
    int i, j, k, sum;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < y; j++)
        {
            sum = 0;
            for (k = 0; k < n; k++)
            {
                sum += s[i][k] * t[k][j];
            }
            p[i][j] = sum;
        }
    }
}

int main()
{
    int m, n, i, j, k, input;
    int x, y;
    int A[100][100], B[100][100], C[100][100];
    do
    {
        menu();
        printf("请选择：>");
        scanf("%d", &input);
        switch (input)
        {
        case 1://转置
            printf("请输入矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("原矩阵：\n");
            Matrix_output(A, m, n);
            Matrix_transpose(A, B, m, n);
            printf("转置后的矩阵：\n");
            Matrix_output(B, n, m);
            break;
        case 2://相加
            printf("请输入第一个矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入第一个矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("请输入第二个矩阵的行数：> ");
            scanf("%d", &x);
            printf("\n");
            printf("请输入第二个矩阵的列数：> ");
            scanf("%d", &y);
            printf("\n");
            if (m == x && n == y)
            {
                printf("请输入矩阵：\n");
                for (i = 0; i < m; i++)
                {
                    for (j = 0; j < n; j++)
                    {
                        scanf("%d", &B[i][j]);
                    }
                }
                printf("第一个矩阵：\n");
                Matrix_output(A, m, n);
                printf("第二个矩阵：\n");
                Matrix_output(B, m, n);
                Matrix_addition(A, B, C, m, n);
                printf("和矩阵：\n");
                Matrix_output(C, m, n);
            }
            else
            {
                printf("这两个矩阵不是同型矩阵，不能相加\n");
            }
            break;
        case 3:
            printf("请输入第一个矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入第一个矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入第一个矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("请输入第二个矩阵的行数：> ");
            scanf("%d", &x);
            printf("\n");
            printf("请输入第二个矩阵的列数：> ");
            scanf("%d", &y);
            printf("\n");
            if (m == x && n == y)
            {
                printf("请输入第二个矩阵：\n");
                for (i = 0; i < m; i++)
                {
                    for (j = 0; j < n; j++)
                    {
                        scanf("%d", &B[i][j]);
                    }
                }
                printf("第一个矩阵：\n");
                Matrix_output(A, m, n);
                printf("第二个矩阵：\n");
                Matrix_output(B, m, n);
                Matrix_subtraction(A, B, C, m, n);
                printf("差矩阵：\n");
                Matrix_output(C, m, n);
            }
            else
            {
                printf("这两个矩阵不是同型矩阵，不能相减\n");
            }
            break;
        case 4:
            printf("请输入矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入这个数:>");
            scanf("%d", &k);
            printf("\n");
            printf("请输入矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("原矩阵：\n");
            Matrix_output(A, m, n);
            Matrix_shucheng(A, B, m, n, k);
            printf("数乘矩阵：\n");
            Matrix_output(B, m, n);
            break;
        case 5:
            printf("请输入第一个矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入第一个矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入第一个矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("请输入第二个矩阵的行数：> ");
            scanf("%d", &x);
            printf("\n");
            printf("请输入第二个矩阵的列数：> ");
            scanf("%d", &y);
            printf("\n");
            if (n == x)
            {
                printf("请输入第二个矩阵：\n");
                for (i = 0; i < x; i++)
                {
                    for (j = 0; j < y; j++)
                    {
                        scanf("%d", &B[i][j]);
                    }
                }
                printf("第一个矩阵：\n");
                Matrix_output(A, m, n);
                printf("第二个矩阵：\n");
                Matrix_output(B, x, y);
                Matrix_multiplication(A, B, C, m, n, x, y);
                printf("相乘矩阵：\n");
                Matrix_output(C, m, y);
            }
            else
            {
                printf("这两个矩阵不能相乘\n");
            }
            break;
        case 0:
            printf("退出计算，欢迎再次使用\n");
            break;
        default:
            printf("输入错误，请从新输入\n");
            break;
        }

    } while (input);

    return 0;
}

现写的：

#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<stdlib.h>
// 矩阵最大大小
#define MAX_MAT_SIZE 4096
// 定义对称矩阵结构体
typedef struct
{
    // 对称矩阵是方阵，只需要一个大小
    int size;
    // 矩阵的数据，因为是对称矩阵，只需要保存(size * (size+1) / 2)个数据
    int* data;
    // data的长度，即(size * (size+1) / 2)
    int num_elements;
}symmat_t;

// 创建对称矩阵
symmat_t symmat_construct(int size);
// 拷贝对称矩阵
void symmat_copy_from(symmat_t* dst, const symmat_t* src);
// 销毁对称矩阵
void symmat_destroy(symmat_t* mat);
// 索引映射
int symmat_map_index(int row, int col);
// 获取矩阵的一个元素
int symmat_get_element(const symmat_t* mat, int row, int col);
// 设置矩阵的一个元素
void symmat_set_element(symmat_t* mat, int row, int col, int value);
// 打印对称矩阵
void symmat_print(const symmat_t* mat);
// 输入对称矩阵
symmat_t symmat_scan();
// 对称矩阵的加法
symmat_t symmat_add(const symmat_t* lhs, const symmat_t* rhs);
// 对称矩阵的减法
symmat_t symmat_sub(const symmat_t* lhs, const symmat_t* rhs);
// 对称矩阵的转置
symmat_t symmat_tranpose(const symmat_t* mat);
// 将对称矩阵保存到文件
void symmat_save(const symmat_t* mat, FILE* stream);
// 从文件读取对称矩阵
symmat_t symmat_load(FILE* stream);

int main()
{
    printf("对称矩阵A\n");
    symmat_t mat_a = symmat_scan();
    symmat_print(&mat_a);

    printf("对称矩阵B\n");
    symmat_t mat_b = symmat_scan();
    symmat_print(&mat_b);

    if (mat_a.size == mat_b.size)
    {
        printf("A+B的结果是：\n");
        symmat_t mat_add = symmat_add(&mat_a, &mat_b);
        symmat_print(&mat_add);
        symmat_destroy(&mat_add);

        printf("A-B的结果是：\n");
        symmat_t mat_sub = symmat_sub(&mat_a, &mat_b);
        symmat_print(&mat_sub);
        symmat_destroy(&mat_sub);
    }
    else
    {
        printf("A和B的大小不同，无法进行加减\n");
    }

    printf("A的转置是：\n");
    symmat_t mat_t = symmat_tranpose(&mat_a);
    symmat_print(&mat_t);
    symmat_destroy(&mat_t);

    const char* filename = "symmat.txt";
    FILE* f = fopen(filename, "w");
    if (f)
    {
        printf("将矩阵A和B保存到文件%s\n", filename);
        symmat_save(&mat_a, f);
        symmat_save(&mat_b, f);
        fclose(f);
    }
    else
    {
        printf("无法打开文件%s进行保存\n", filename);
    }

    f = fopen(filename, "r");
    if (f)
    {
        symmat_t mat_c = symmat_load(f);
        symmat_t mat_d = symmat_load(f);
        printf("从文件%s加载矩阵A和B\n", filename);
        printf("对称矩阵A\n");
        symmat_print(&mat_c);
        printf("对称矩阵B\n");
        symmat_print(&mat_d);
        symmat_destroy(&mat_c);
        symmat_destroy(&mat_d);
        fclose(f);
    }
    else
    {
        printf("无法打开文件%s进行加载\n", filename);
    }

    symmat_destroy(&mat_a);
    symmat_destroy(&mat_b);
    return 0;
}

// 创建对称矩阵
symmat_t symmat_construct(int size)
{
    assert(size >= 0 && size <= MAX_MAT_SIZE);
    symmat_t ret;
    ret.size = size;
    ret.num_elements = (size * (size + 1) / 2);
    int bytes = ret.num_elements * sizeof(int);
    if (size > 0)
    {
        ret.data = (int*)malloc(bytes);
        assert(ret.data);
        memset(ret.data, 0, bytes);
    }
    else
    {
        ret.data = NULL;
    }
    return ret;
}

// 拷贝对称矩阵
void symmat_copy_from(symmat_t* dst, const symmat_t* src)
{
    assert(dst->size == src->size);
    memcpy(dst->data, src->data, dst->num_elements * sizeof(int));
}

// 销毁对称矩阵
void symmat_destroy(symmat_t* mat)
{
    mat->size = 0;
    mat->num_elements = 0;
    free(mat->data);
}

// 索引映射
// u 0 0
// v w 0    -->  u v w x y z
// x y z
int symmat_map_index(int row, int col)
{
    if (col > row)
    {
        int tmp = row;
        row = col;
        col = tmp;
    }
    return (row * (row + 1) / 2 + col);
}
// 获取矩阵的一个元素
int symmat_get_element(const symmat_t* mat, int row, int col)
{
    int index = symmat_map_index(row, col);
    assert(index < mat->num_elements);
    return mat->data[index];
}
// 设置矩阵的一个元素
void symmat_set_element(symmat_t* mat, int row, int col, int value)
{
    int index = symmat_map_index(row, col);
    assert(index < mat->num_elements);
    mat->data[index] = value;
}
// 打印对称矩阵
void symmat_print(const symmat_t* mat)
{
    for (int i = 0; i < mat->size; ++i)
    {
        printf("|");
        for (int j = 0; j < mat->size; ++j)
        {
            printf("%d", symmat_get_element(mat, i, j));
            if (j != mat->size - 1)printf(" \t");
        }
        printf("|\n");
    }
}
// 输入对称矩阵
symmat_t symmat_scan()
{
    int size = 0;
    printf("请输入矩阵大小：");
    scanf("%d", &size);
    symmat_t ret = symmat_construct(size);
    printf("请输入%d个元素：\n", ret.num_elements);
    for (int i = 0; i < ret.num_elements; ++i)
    {
        scanf("%d", &ret.data[i]);
    }
    return ret;
}

// 对称矩阵的加法
symmat_t symmat_add(const symmat_t* lhs, const symmat_t* rhs)
{
    assert(lhs->size == rhs->size);
    symmat_t ret = symmat_construct(lhs->size);
    for (int i = 0; i < lhs->num_elements; ++i)
        ret.data[i] = lhs->data[i] + rhs->data[i];
    return ret;
}

// 对称矩阵的减法
symmat_t symmat_sub(const symmat_t* lhs, const symmat_t* rhs)
{
    assert(lhs->size == rhs->size);
    symmat_t ret = symmat_construct(lhs->size);
    for (int i = 0; i < lhs->num_elements; ++i)
        ret.data[i] = lhs->data[i] - rhs->data[i];
    return ret;
}

// 对称矩阵的转置
symmat_t symmat_tranpose(const symmat_t* mat)
{
    // 对称矩阵的转置是它自己
    // 可以直接拷贝数据
    symmat_t ret = symmat_construct(mat->size);
    symmat_copy_from(&ret, mat);
    return ret;
}

// 将对称矩阵保存到文件
void symmat_save(const symmat_t* mat, FILE* stream)
{
    fprintf(stream, " %d ", mat->size);
    for (int i = 0; i < mat->num_elements; ++i)
        fprintf(stream, " %d ", mat->data[i]);
}

// 从文件读取对称矩阵
symmat_t symmat_load(FILE* stream)
{
    int d;
    if (fscanf(stream, " %d ", &d) == 1)
    {
        symmat_t ret = symmat_construct(d);
        for (int i = 0; i < ret.num_elements; ++i)
            fscanf(stream, " %d ", &ret.data[i]);
        return ret;
    }
    symmat_t empty_mat = symmat_construct(0);
    return empty_mat;
}

保存是可以的，存入因为你要运算，每次都要不同的输入，所以最好动态从控制台读入

#include <stdio.h>
void menu()
{
    printf("****************************************************************\n");
    printf("****************************************************************\n");
    printf("**********************欢迎使用矩阵计算器************************\n");
    printf("              1.转置2.加法3.减法4.数乘5.乘法0.退出              \n");
    printf("****************************************************************\n");
    printf("****************************************************************\n");
    printf("****************************************************************\n");
}
 
void  Matrix_output(int(*s)[100], int m, int n)//输出
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("%2d ", s[i][j]);
        }
        printf("\n");
    }
    FILE* fp = fopen("a.txt", "w+");
    if (fp == NULL) {
        printf("无文件");
    }
    for (i = 0; i < m; i++) {

        for (j = 0; j < n; j++) {
            fprintf(fp, "%2d", s[i][j]);
        }
        fprintf(fp, "\n");
    }
    fclose(fp);
}
 
void  Matrix_transpose(int(*s)[100], int(*t)[100], int m, int n)//转置
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            t[j][i] = s[i][j];
        }
    }
}
void Matrix_addition(int(*s)[100], int(*t)[100], int(*p)[100], int m, int n)//相加
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            p[i][j] = s[i][j] + t[i][j];
        }
    }
}
 
void Matrix_subtraction(int(*s)[100], int(*t)[100], int(*p)[100], int m, int n)//相减
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            p[i][j] = s[i][j] - t[i][j];
        }
    }
}
 
void Matrix_shucheng(int(*s)[100], int(*t)[100], int m, int n, int k)//数乘
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            t[i][j] = k * s[i][j];
        }
    }
}
 
void Matrix_multiplication(int(*s)[100], int(*t)[100], int(*p)[100], int m, int n, int x, int y)//相乘
{
    int i, j, k, sum;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < y; j++)
        {
            sum = 0;
            for (k = 0; k < n; k++)
            {
                sum += s[i][k] * t[k][j];
            }
            p[i][j] = sum;
        }
    }
}
 void print(){
    
      
 }

int main()
{
    int m, n, i, j, k, input;
    int x, y;
    int A[100][100], B[100][100], C[100][100];
    do
    {
        menu();
        printf("请选择：>");
        scanf("%d", &input);
        switch (input)
        {
        case 1://转置
            printf("请输入矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("原矩阵：\n");
            Matrix_output(A, m, n);
            Matrix_transpose(A, B, m, n);
            printf("转置后的矩阵：\n");
            Matrix_output(B, n, m);
            break;
        case 2://相加
            printf("请输入第一个矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入第一个矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("请输入第二个矩阵的行数：> ");
            scanf("%d", &x);
            printf("\n");
            printf("请输入第二个矩阵的列数：> ");
            scanf("%d", &y);
            printf("\n");
            if (m == x && n == y)
            {
                printf("请输入矩阵：\n");
                for (i = 0; i < m; i++)
                {
                    for (j = 0; j < n; j++)
                    {
                        scanf("%d", &B[i][j]);
                    }
                }
                printf("第一个矩阵：\n");
                Matrix_output(A, m, n);
                printf("第二个矩阵：\n");
                Matrix_output(B, m, n);
                Matrix_addition(A, B, C, m, n);
                printf("和矩阵：\n");
                Matrix_output(C, m, n);
            }
            else
            {
                printf("这两个矩阵不是同型矩阵，不能相加\n");
            }
            break;
        case 3:
            printf("请输入第一个矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入第一个矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入第一个矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("请输入第二个矩阵的行数：> ");
            scanf("%d", &x);
            printf("\n");
            printf("请输入第二个矩阵的列数：> ");
            scanf("%d", &y);
            printf("\n");
            if (m == x && n == y)
            {
                printf("请输入第二个矩阵：\n");
                for (i = 0; i < m; i++)
                {
                    for (j = 0; j < n; j++)
                    {
                        scanf("%d", &B[i][j]);
                    }
                }
                printf("第一个矩阵：\n");
                Matrix_output(A, m, n);
                printf("第二个矩阵：\n");
                Matrix_output(B, m, n);
                Matrix_subtraction(A, B, C, m, n);
                printf("差矩阵：\n");
                Matrix_output(C, m, n);
            }
            else
            {
                printf("这两个矩阵不是同型矩阵，不能相减\n");
            }
            break;
        case 4:
            printf("请输入矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入这个数:>");
            scanf("%d", &k);
            printf("\n");
            printf("请输入矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("原矩阵：\n");
            Matrix_output(A, m, n);
            Matrix_shucheng(A, B, m, n, k);
            printf("数乘矩阵：\n");
            Matrix_output(B, m, n);
            break;
        case 5:
            printf("请输入第一个矩阵的行数：> ");
            scanf("%d", &m);
            printf("\n");
            printf("请输入第一个矩阵的列数：> ");
            scanf("%d", &n);
            printf("\n");
            printf("请输入第一个矩阵：\n");
            for (i = 0; i < m; i++)
            {
                for (j = 0; j < n; j++)
                {
                    scanf("%d", &A[i][j]);
                }
            }
            printf("请输入第二个矩阵的行数：> ");
            scanf("%d", &x);
            printf("\n");
            printf("请输入第二个矩阵的列数：> ");
            scanf("%d", &y);
            printf("\n");
            if (n == x)
            {
                printf("请输入第二个矩阵：\n");
                for (i = 0; i < x; i++)
                {
                    for (j = 0; j < y; j++)
                    {
                        scanf("%d", &B[i][j]);
                    }
                }
                printf("第一个矩阵：\n");
                Matrix_output(A, m, n);
                printf("第二个矩阵：\n");
                Matrix_output(B, x, y);
                Matrix_multiplication(A, B, C, m, n, x, y);
                printf("相乘矩阵：\n");
                Matrix_output(C, m, y);
            }
            else
            {
                printf("这两个矩阵不能相乘\n");
            }
            break;
        case 0:
            printf("退出计算，欢迎再次使用\n");
            break;
        default:
            printf("输入错误，请从新输入\n");
            break;
        }
 
    } while (input);
 
    return 0;
}

【列运算_C语言实现矩阵加法、减法、乘法和数乘运算】https://minipro.baidu.com/ma/qrcode/parser?app_key=y1lpwNoOyVpW33XOPd72rzN4aUS43Y3O&launchid=1f0f8da1-3482-4e73-a0d7-2413e9ab198d&path=%2Fpages%2Fblog%2Findex%3FblogId%3D112588525%26_swebFromHost%3Dbaiduboxapp

c语言矩阵存储,C语言实现特殊矩阵存储
https://wenku.baidu.com/view/5178bd2b874769eae009581b6bd97f192279bf82.html

你看一下我的代码：

#include <stdio.h>
 
int main(void){
    int L, R, num;
    printf("请输入两个数组的行与列");
    scanf("%d%d", &R, &L);
    int arr_A[L][R] = {0}, arr_B[L][R] = {0};
    for(int i = 0; i < R; i++){
        for(int j = 0; j < L; j++){
            printf("请输入A矩阵中的第%d行第%d个值", i, j);
            scanf("%d", &arr_A[i][j]);
        }
        for(int j = 0; j < L; j++){
            printf("请输入B矩阵中的第%d行第%d个值", i, j);
            scanf("%d", &arr_B[i][j]);
        }
    }
    printf("请输入你的选项:\n1.进行加法运算\n2.进行减法运算\n");
    printf("请输入你的选项：");
    while(1){
        scanf("%d", &num);
        if(num == 1|| num == 2){
            break;
        }
        printf("输入有误请重新输入哦！\n");
    }
    switch(num){
        case 1: printf("进行加法运算..\n");
            for(int i = 0; i < R; i++){
                for(int j = 0; j < L; j++){
                    arr_A[i][j] += arr_B[i][j];
                }
                for(int j = 0; j < L; j++){
                    printf("%d\t", arr_A[i][j]);
                }
                printf("\n");
            }
        break;
        case 2: printf("进行减法运算..\n");
            for(int i = 0; i < R; i++){
                for(int j = 0; j < L; j++){
                    arr_A[i][j] -= arr_B[i][j];
                }
                for(int j = 0; j < L; j++){
                    printf("%d\t", arr_A[i][j]);
                }
                printf("\n");
            }
        break;
    }
    return 0;
}

可以参照这篇文章，学习下。列运算_C语言实现矩阵加法、减法、乘法和数乘运算_机核的博客-CSDN博客