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

 更新时间:2015年07月30日 16:05:14   作者:王维来  
这片文章介绍了如何利用二维动态数组指针做矩阵运算,需要的朋友可以参考下

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

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;
}


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

相关文章

  • 全面解析C++中的new,operator new与placement new

    全面解析C++中的new,operator new与placement new

    以下是C++中的new,operator new与placement new进行了详细的说明介绍,需要的朋友可以过来参考下
    2013-09-09
  • C++实现五子棋游戏

    C++实现五子棋游戏

    这篇文章主要为大家详细介绍了C++实现五子棋游戏,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2018-01-01
  • C++中运算符重载的规则语法实例

    C++中运算符重载的规则语法实例

    今天小编就为大家分享一篇关于C++中运算符重载的规则语法实例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2018-12-12
  • VC++中图像处理类CBitmap的用法

    VC++中图像处理类CBitmap的用法

    使用VC进行图像处理的时候,CBitmap类为我们提供了丰富的位图处理函数,本文总结了该类的相关函数和常用使用方法,包括加载位图,显示位图,析构CBitmap资源以及在内存中保存位图等内容。
    2015-11-11
  • C++实现LeetCode(40.组合之和之二)

    C++实现LeetCode(40.组合之和之二)

    这篇文章主要介绍了C++实现LeetCode(40.组合之和之二),本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-07-07
  • c++ 子类构造函数初始化及父类构造初始化的使用

    c++ 子类构造函数初始化及父类构造初始化的使用

    这篇文章主要介绍了c++ 子类构造函数初始化及父类构造初始化的使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-07-07
  • VC++ 中ListCtrl经验总结

    VC++ 中ListCtrl经验总结

    这篇文章主要介绍了VC++ 中ListCtrl经验总结的相关资料,需要的朋友可以参考下
    2015-06-06
  • Qt图形图像开发曲线图表模块QChart库缩放/平移详细方法与实例

    Qt图形图像开发曲线图表模块QChart库缩放/平移详细方法与实例

    这篇文章主要介绍了Qt图形图像开发曲线图表模块QChart库缩放/平移详细方法与实例,需要的朋友可以参考下
    2020-03-03
  • C++实现下载的代码

    C++实现下载的代码

    这篇文章主要介绍了C++实现下载的代码,以下载百度图片为例较为完整的讲述了C++下载的具体实现方法,需要的朋友可以参考下
    2014-10-10
  • 常用Hash算法(C语言的简单实现)

    常用Hash算法(C语言的简单实现)

    下面小编就为大家带来一篇常用Hash算法(C语言的简单实现)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2016-09-09

最新评论