学习二维动态数组指针做矩阵运算的方法

本文分享了利用二维动态数组指针做矩阵运算的实现代码。

1. 头文件

// juzhen 2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "stdlib.h"
#include "windows.h"
#define OK 0
#define NG -1
typedef struct mat
{
int nRow;     /* 行数        */
int nCol;     /* 列数        */
int* pData;    /* 指向矩??体的指? */
}MAT;

2. 程序代码

#include "stdafx.h"
#include "Matrix_cal.h"
/* Entity and initial matrix of the application matrix function */
int MATAlloc(MAT *pMat, int nRow, int nCol)
{
  pMat->pData = (int *) malloc (nRow * nCol * sizeof(int) );
  if(NULL == pMat->pData)
  {
    printf("Memary is error!\n");
    return NG;
  }
  for(int i=0; i<nRow; ++i)
  {
    for(int j=0; j<nCol; ++j)
    {
      *(pMat->pData + i*nCol + j)=0;
    }
  }
  pMat->nRow = nRow;
  pMat->nCol = nCol;
  return OK;
}

/* Release the memory space and reset the matrix data function */
void MATFree(MAT* pMat)
{
  free(pMat->pData);
  pMat->pData = NULL;
  pMat->nRow = 0;
  pMat->nCol = 0;
}

/* Import of matrix function */
int MATAssign (MAT* pMat1, const MAT* pMat2)
{
  MATAlloc(pMat1, pMat2->nRow, pMat2->nCol);
  for(int i=0; i < pMat1->nRow; ++i)
  {
    for(int j=0; j < pMat1->nCol; ++j)
    {
      *(pMat1->pData + i * pMat1->nCol + j) = *(pMat2->pData + i * pMat1->nCol + j);
    }
  }
  return OK;
}

/* Matrix sum function */
int MATAdd(const MAT* pMat1, const MAT* pMat2, MAT* pMat3)
{
  MATAlloc(pMat3, pMat1->nRow, pMat1->nCol);
  if((pMat1->nRow == pMat2->nRow) && (pMat1->nCol == pMat2->nCol))
  {
    for(int i=0; i<pMat1->nRow; ++i)
    {
      for(int j=0; j<pMat1->nCol; ++j)
      {
        *(pMat3->pData + i * pMat3->nCol + j) = *(pMat1->pData + i * pMat1->nCol + j) + *(pMat2->pData + i * pMat1->nCol + j);
      }
    }
    return OK;
  }
  else
  {
    printf("Not add!\n");
    return NG;
  }

}

/* Matrix subtraction function */
int MATSub(const MAT* pMat1, const MAT* pMat2, MAT* pMat3)
{
  MATAlloc(pMat3, pMat1->nRow, pMat1->nCol);
  if((pMat1->nRow == pMat2->nRow) && (pMat1->nCol == pMat2->nCol))
  {
    for(int i=0; i<pMat1->nRow; ++i)
    {
      for(int j=0; j<pMat1->nCol; ++j)
      {
        *(pMat3->pData + i * pMat3->nCol + j) = *(pMat1->pData + i * pMat1->nCol + j) - *(pMat2->pData + i * pMat1->nCol + j);
      }
    }
    return OK;
  }
  else
  {
    printf("Not Sub!\n");
    return NG;
  }

}

/* Matrix clear */
void MATClear(MAT* pMat)
{
  for(int i=0; i<pMat->nRow; ++i)
  {
    for(int j=0; j<pMat->nCol; ++j)
    {
      *(pMat->pData + i * pMat->nCol + j)=0;
    }
  }
}

/* Matrix multiplication C function */
void MATMulC (MAT* pMat, int C)
{
  for(int i=0; i<pMat->nRow; ++i)
  {
    for(int j=0; j<pMat->nCol; ++j)
    {
      *(pMat->pData + i * pMat->nCol + j) = C * (*(pMat->pData + i * pMat->nCol + j) );
    }
  }
}

/* Matrix multiplication function */
int MATMul (const MAT* pMat1, const MAT* pMat2, MAT* pMat3)
{
  MATAlloc(pMat3, pMat1->nRow, pMat2->nCol);
  if(pMat1->nCol == pMat2->nRow)
  {
    for(int i=0; i<pMat1->nRow; ++i)
    {
      for(int j=0; j<pMat2->nCol; ++j)
      {
        for(int k=0; k<pMat1->nCol; ++k)
        {
          *(pMat3->pData + i * pMat2->nCol+j) += *(pMat1->pData + i * pMat2->nRow + k) * (*(pMat2->pData + k * pMat2->nCol + j) );
        }
      }
    }
    return OK;
  }
  else
  {
    printf("not Mul\n");
    return NG;
  }
}
/* Matrix transpose function */
int MATTransport(const MAT* pMat1, MAT* pMat2)
{
  MATAlloc(pMat2, pMat1->nCol, pMat1->nRow);
  for(int i=0; i<pMat1->nRow; ++i)
    {
      for(int j=0; j<pMat1->nCol; ++j)
      {
        *(pMat2->pData + j * pMat1->nRow + i) = *(pMat1->pData + i * pMat1->nCol + j);
      }
    }
  return OK;
}
/*
bool Check_digit(char *kk)
{
  int a = strlen(kk);
  for(int i = 0; i<a; ++i)
  {
    if( ( (int) (*(kk + i) ) > 48) && ( (int) (*(kk + i) ) < 57 || (int) (*(kk + i) ) == 32) )
    {
      return 1;
    }
  }
  return 0;
}

*/

/* Matrix initialization */
void MATinit(MAT *pMat)
{
  bool kos=1;
  int nRow = 0, nCol = 0;
  printf("Please input the number of rows: ");
  scanf_s("%d",&nRow);
  putchar('\n');
  printf("Please input the number of columns: ");
  scanf_s("%d",&nCol);
  putchar('\n');
  printf("Please input %dX%d Matrix:\n",nRow,nCol);
  kos=MATAlloc(pMat,nRow,nCol);
  for(int i=0; i<nRow; ++i)
  {
    for(int j=0; j<nCol; ++j)
    {
      scanf("%d", pMat->pData + i*nCol + j);
    }
  }
}
  /*char arr[100][100]={0};
  for(int i=0; i<nRow; ++i)
  {
    for(int j=0; j<nCol; ++j)
    {
      scanf("%c", &arr[i][j]);
      kos = Check_digit(&arr[i][j]);
    }
  }
  //ks= atoi(arr[0]);
  while(kos)
  {
    printf(" input is error,Please input again!");
    for(int i=0; i<nRow; ++i)
    {
      for(int j=0; j<nCol; ++j)
      {
        scanf("%c", arr[i]);
      }
    }
    kos = Check_digit(arr[0]);
    //ks= atoi(arr[0]);
  }
  for(int i=0; i<nRow; ++i)
  {
    for(int j=0; j<nCol; ++j)
    {
      *(pMat->pData + i*nCol + j) = atoi(&arr[i][j]);
    }
  }

}
*/

/* Output matrix */
void Print(MAT *pMat)
{
  printf("The result is:\n");
  for(int i = 0; i < pMat->nRow; ++i)
  {
    for(int j=0; j<pMat->nCol; ++j)
    {
      printf("%d ",*( pMat->pData + i * pMat->nCol + j) );
    }
    putchar('\n');
  }
}

int _tmain(int argc, _TCHAR* argv[])
{
  int nRow = 1,nCol = 1,sign = 1,C = 1,work = 1,sigal=0;
  MAT Mat, Mat1, Mat2;
  MAT *pMat = &Mat;
  MAT *pMat1 = &Mat1;
  MAT *pMat2 = &Mat2;
  while(work)
  {
    system("cls");
    printf("           Welcome To The Matrix Operation system!   \n");
    printf("------------------------------------------------\n");
    printf("1: Open The Generating matrix function!\n");
    printf("2: Open The Release matrix function!\n");
    printf("3: Open The Import matrix function!\n");
    printf("4: Open The Add matrix function!\n");
    printf("5: Open The Matrix subtraction function!\n");
    printf("6: Open The Clear matrix function!\n");
    printf("7: Open The Matrix multiplication C function!\n");
    printf("8: Open The Matrix multiplication function!\n");
    printf("9: Open The Matrix transpose function!\n");
    printf("------------------------------------------------\n");
    printf("Please Select operation type:");
    scanf("%d",&sign);
    switch(sign)
    {
      case 1:
      {
       MATinit(pMat);
       Print(pMat);
      }
      break;
      case 2:
      {
        MATinit(pMat);
        Print(pMat);
        MATFree(pMat);
      }
      break;
      case 3:
      {

        MATinit(pMat2);
        MATAssign (pMat1, pMat2);
        Print(pMat1);
      }
      break;
      case 4:
      {
        MATinit(pMat1);
        MATinit(pMat2);
        sigal = MATAdd(pMat1, pMat2,pMat);
        if(0 == sigal)
        {
          Print(pMat);
        }
      }
      break;
      case 5:
      {
        MATinit(pMat1);
        MATinit(pMat2);
        sigal = MATSub(pMat1, pMat2,pMat);
        if(0 == sigal)
        {
          Print(pMat);
        }
      }
      break;
      case 6:
      {
        MATinit(pMat);
        Print(pMat);
        MATClear(pMat);
        Print(pMat);
      }
      break;
      case 7:
      {
        printf("Please input the number of C: ");
        scanf("%d",&C);
        putchar('\n');
        MATinit(pMat);
        MATMulC (pMat, C);
        Print(pMat);
      }
      break;
      case 8:
      {
        MATinit(pMat1);
        MATinit(pMat2);
        sigal = MATMul (pMat1, pMat2, pMat);
        if(0 == sigal)
        {
          Print(pMat);
        }
      }
      break;
      case 9:
      {
        MATinit(pMat1);
        MATTransport(pMat1, pMat2);
        Print(pMat2);
      }
      break;
      default: printf("input is error!");
    }
    printf("Whether exit the Matrix calculation system?(1 is not exit,0 is exit)\n");    //whether exit the system.
    scanf("%d", &work);
    fflush(stdin);
    while (work != 0 && work != 1)                             //work must is 1 or 0.
    {
      printf(" Input is error,Please input again!\n");
      scanf("%d", &work);
      fflush(stdin);
    }
  }
  printf("\n-------------Thanks For You Using The Matrix Calculation System !--------------\n");
  Sleep(2000);                                        //deley some times.
  return 0;
}

以上就是实现二维动态数组指针做矩阵运算的代码，希望对大家的学习有所帮助。