#include<stdio.h>
#define N 4
#define M (N+1)*N/2
void print(int c[N][N])
{
    int i,j;
    for(i = 0;i<N;i++)
        for(j = 0;j<N;j++)
            scanf("%d",&c[i][j]);
}
int * save(int a[N][N] )
{
    int i,j,k;
    int d[M];
    for(i = 0;i<N;i++)
        for(j = 0;j<N;j++)
        {
        for(k = 0;k<M;k++)
        {
            if(i>=j)
                d[k] = a[i][j];
        }
        return d;
            }
}
int * add(int a[N][N],int b[N][N])
{
    int i;
    int *p,*q;
    p = save(a);
    q = save(b);
    int k[M];
    for(i = 0;i<M;i++)
        k[i] = (*(p+i))+(*(q+i));
    return k;

        
}
int * muti(int a[N][N],int b[N][N])
{
    int i,J[M];
    int *p,*q;
    p = save(a);
    q = save(b);
    for(i = 0;i<M;i++)
        J[i] = (*(p+i))*(*(q+i));
    return J;
}
void show(int *p)
{
    int a[M];
    int i,j,f;
    for(i = 0;i<N;i++)
    {
        for(j = 0;j<N;j++)
            if(i>=j)
                for(f = 0;f<M;f++)
                {
                a[i][j] = *(p+f);
                a[j][i] = *(p+f);
                }
                }
    for(i = 0;i<N;i++)
        for(j = 0;j<N;j++)
            printf("%d",a[i][j]);
}

void main()
{
    int a[N][N],b[N][N],*p,*q,i,j;
    p = a;
    q = b;
    printf("请输入矩阵a:\n");
    print(a);
    printf("a矩阵如下：\n");
    for(i = 0;i<N;i++)
        for(j = 0;j<N;j++)
            printf("%d",a[i][j]);
        printf("\n");
    printf("请输入矩阵b:\n");
    for(i = 0;i<N;i++)
        for(j = 0;j<N;j++)
            printf("%d",b[i][j]);
        pintf("\n");
    printf("b矩阵如下:\n");
    show(b);
    printf("a,b矩阵和:\n");
    show(add(a,b));
    printf("a,b矩阵积:\n");
    show(muti(a,b));
}

什么是对称矩阵，矩阵的大小限制了吗

一个矩阵除对角线上的元素外，其余元素关于对角线对称相等。
我把大小暂设为4*4的矩阵

有这个限制后就非常简单了，用二维数组存储矩阵，然后矩阵运算只要会运算方法就非常简单

我尝试用的压缩存储对称矩阵，主要是几个返回指针类型的函数，我觉得自己用得不熟练，尤其是return语句的问题，
嘿嘿，诸葛大侠，帮我看看咯

首先第一个print函数就有错，要么你把指针传进去要么你把数组返回给主函数

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

#define MAT_ELE int

struct Matrix
{
   MAT_ELE **ele;
   int M;
   int N;
};

typedef struct Matrix Mat;

Mat* new(int M, int N)
{
    Mat* mat = (Mat*)malloc(sizeof(Mat));
    mat->M = M;
    mat->N = N;
    mat->ele = (MAT_ELE**)malloc(sizeof(MAT_ELE*) * M);
    int i;
    for (i = 0; i < M; i++)
    {
        mat->ele[i] = (MAT_ELE*)malloc(sizeof(MAT_ELE) * N);
    }

    return mat;
}

void delete(Mat* mat)
{
    int i;
    for (i = 0; i < mat->M; i++)
    {
        free(mat->ele[i]);
    }
    free(mat->ele);
    free(mat);
}


Mat* add(Mat *a, Mat *b)
{
    assert(a->M == b->M && a->N == b->N);

    Mat *c = new(a->M, a->N);

    int i, j;
    for (i = 0; i < a->M; i++)
      for (j = 0; j < a->N; j++)
      {
          c->ele[i][j] = a->ele[i][j] + b->ele[i][j];
      }

    return c;
}

Mat* mul(Mat *a, Mat *b)
{
    assert(a->M == b->N && a->N == b->M);

    Mat *c = new(a->M, b->N);

    int i, j;
    for (i = 0; i < a->M; i++)
      for (j = 0; j < a->N; j++)
      {
          c->ele[i][i] = a->ele[i][j] * b->ele[j][i];
      }

    return c;
}

void show(Mat *a)
{
    printf("Mat = \n");
    int i, j;
    for (i = 0; i < a->M; i++)
      for (j = 0; j < a->N; j++)
      {
          printf("%d ", a->ele[i][j]);
          if (j == a->N -1)
            printf("\n");
      }
}

int main(void)
{
    Mat *a, *b, *c;
    a = new(3, 4);
    srand(time(NULL));
    int i, j;
    for (i = 0; i < 3; i++)
      for (j = 0; j < 4; j++)
      {
          a->ele[i][j] = rand() % 10;
      }
    show(a);

    b = new(4, 3);
    for (i = 0; i < 4; i++)
      for (j = 0; j < 3; j++)
      {
          b->ele[i][j] = rand() % 10;
      }
    show(b);

    c = new(3, 4);
    for (i = 0; i < 3; i++)
      for (j = 0; j < 4; j++)
      {
          c->ele[i][j] = rand() % 10;
      }
    show(c);

    Mat *d = add(a, c);
    show(d);

    Mat *e = mul(a, b);
    show(e);

    delete(a);
    delete(b);
    delete(c);
    delete(d);
    delete(e);

    return 0;
}

这是我写的一个程序，可供参考