设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

帖子
»论坛 › 电子技术分类讨论区 › 资料共享 › C++面向对象程序设计实验报告 带两种定义矩阵方法源程序
返回列表 发新帖
查看: 2529|回复: 1
收起左侧

C++面向对象程序设计实验报告 带两种定义矩阵方法源程序

[复制链接]
ID:171414 发表于 2017-3-17 00:06 | 显示全部楼层 |阅读模式
0.png
完整的报告下载（word格式）：
第2次实验.zip (2.48 MB, 下载次数: 4)



下面是部分内容预览：
----------------------------------------------------------------------------
C++面向对象程序设计实验报告

实验报告

学生姓名：吴琪学    号：19215115专业班级：计科151

一．实验目的
（1）熟练Visual Studio 6.0和2008两种开发环境，包括基本操作命令、相应菜单项和快捷键；掌握C++程序的基本结构及相应编辑、编译、调试和运行的方法；
（2）复习数组、单链表等数据结构的编程实现；
（3）掌握利用数组、单链表实现n×n矩阵的存储、数乘、转置和旋转反射等
二．实验内容
实验1：矩阵的数乘
（1）程序功能简介
根据矩阵处理的数据知识，编程实现矩阵的数乘程序。
（2）程序设计要求
① 实现n×n矩阵的数乘，其中n为用户输入的任意整数；
② 先采用数组来表示矩阵，再采用单链表来表示矩阵，分别实现两种数据结构下的矩阵数乘，并比较两种数据结构的程序实现难易程度；
③生成相应可执行程序，并提交实验报告和可执行程序。
实验2：矩阵的旋转反射和转置
（1）程序功能简介
根据矩阵处理的数据知识，编程实现矩阵旋转反射和转置程序。
（2）程序设计要求
① 实现n×n矩阵的旋转反射和转置，其中n为用户输入的任意整数；
② 先采用数组来表示矩阵，再采用单链表来表示矩阵，分别实现两种数据结构下的矩阵旋转反射和转置程序，并比较两种数据结构的程序实现难易程度；
③生成相应可执行程序，并提交实验报告和可执行程序。

三．实验环境
PC微机
DOS操作系统或 Windows 操作系统
Visual c++程序集成环境
四．实验内容和步骤
实验1：矩阵的数乘
程序设计说明
① 矩阵数乘的数据原理相对简单，主要是解决矩阵的表示，可以采用数组和单链表两种方式；
② 先采用数组来表示矩阵，实现相应矩阵数乘程序；
③ 再采用单链表来表示矩阵，相应矩阵的数乘操作变得简单。
实验2：矩阵的旋转反射和转置
程序设计说明
① 矩阵旋转反射和转置的数据原理相对简单，主要是解决矩阵的表示，可以采用数组和单链表两种方式；
② 先采用数组来表示矩阵，实现相应旋转反射和转置程序；
③ 再采用单链表来表示矩阵，相应矩阵的旋转反射和转置操作变得简单，只要按一定的算法改变链表中节点的次序即可。
五．实验数据及处理结果
【实验1】
【设计思路】
输入矩阵n*n的大小n，数乘的大小，按行列顺序输入矩阵的赋值，输出矩阵的初始状态以及数乘的结果。
【数据输入】输入矩阵n*n的大小n，数乘的大小，按行列顺序输入矩阵的赋值。
【数据输出】输出矩阵的初始状态以及数乘的结果。


1.001.jpg

【结果及截图】
答：运行程序，（对于数组）输入矩阵大小4，按行列顺序输入矩阵赋值：9 6 3 8 5 2 7 4 1 7 8 9 4 5 6 0，输入旋转角度90，选择x反射，矩阵初始布局以及特殊变换后的布局如下：
1.005.jpg
（对于链表）输入矩阵大小4，按行列顺序输入矩阵赋值：6 4 2 8 4 3 6 7 1 2 3 6 4 1 7 5，输入旋转角度270，选择y反射，矩阵初始布局以及特殊变换后的布局如下：
1.006.jpg


六、实验总结及体会

       通过本次实验，熟练了Visual Studio 6.0和2008两种开发环境，包括基本操作命令、相应菜单项和快捷键，并掌握C++程序的基本结构及相应编辑、编译、调试和运行的方法。此外，复习数组、单链表等数据结构的编程实现，掌握利用数组、单链表实现n×n矩阵的存储、数乘、转置和旋转反射等操作的方法，对数据存储和算法复杂度有了更深刻的理解。




【源程序实现】
【shucheng.h】
  1. //链表操作

  3. typedef struct LNode{

  5.               int num;

  7.               LNode *next;

  9. }*LinkList,LNode;

  11. void initList(int n,LinkList &list);

  13. void meanList(int n,LinkList &list);

  15. void valueList(int k,int n,LinkList &list);

  17. void printList(int n,LinkList &list);



  21. //数组操作

  23. void initma(int n,int **&matrix);

  25. void meanma(int n,int **matrix);

  27. void valuema(int k,int n,int **matrix);

  29. void printma(int n,int **matrix);

  31. 【shucheng.cpp】

  33. #include"shucheng.h"

  35. #include"iostream"

  37. using namespace std;



  41. void initma(int n,int **&matrix){

  43.               matrix=new int*[n];

  45.               int i;

  47.               for(i=0;i<n;i++){

  49.                             matrix[i]=new int[n];

  51.               }

  53. }



  57. void meanma(int n,int **matrix){

  59.               int i,j;

  61.               cout<<"please input 数组矩阵 in order:";

  63.               for(i=0;i<n;i++){

  65.                             for(j=0;j<n;j++){

  67.                                           cin>>matrix[i][j];

  69.                             }

  71.               }

  73. }



  77. void valuema(int k,int n,int **matrix){

  79.               int i,j;

  81.               for(i=0;i<n;i++){

  83.                             for(j=0;j<n;j++){

  85.                                           matrix[i][j]*=k;

  87.                             }

  89.               }

  91. }



  95. void printma(int n,int **matrix){

  97.               int i,j;

  99.               for(i=0;i<n;i++){

  101.                             for(j=0;j<n;j++){

  103.                                           cout<<matrix[i][j]<<" ";

  105.                             }

  107.                             cout<<endl;

  109.               }            

  111. }



  115. void initList(int n,LinkList &list){

  117.               int i;

  119.               list=new LNode;

  121.               list->num=1;

  123.               list->next=NULL;



  127.               LinkList p;

  129.               for(i=0;i<n*n;i++){

  131.                             p=new LNode;

  133.                             p->num=1;//初值定为1

  135.                             p->next=list->next;

  137.                             list->next=p;

  139.               }

  141. }



  145. void meanList(int n,LinkList &list){

  147.               LinkList p=list->next;

  149.               cout<<"please input 链表矩阵 in order:";

  151.               int i;

  153.               for(i=0;i<n*n;i++){

  155.                             cin>>p->num;

  157.                             p=p->next;

  159.               }

  161. }



  165. void valueList(int k,int n,LinkList &list){

  167.               LinkList p=list->next;

  169.               int i;

  171.               for(i=0;i<n*n;i++){

  173.                             p->num*=k;

  175.                             p=p->next;

  177.               }

  179. }



  183. void printList(int n,LinkList &list){

  185.               LinkList p=list->next;

  187.               int i;

  189.               for(i=0;i<n*n;i++){

  191.                             cout<num<<" ";

  193.                             p=p->next;

  195.                             if((i+1)%n==0)

  197.                                           cout<<endl;

  199.               }

  201. }
复制代码


【test.cpp】
  1. #include"shucheng.h"

  3. #include"iostream"

  5. using namespace std;



  9. void main(){

  11.               int n;

  13.               cout<<"please input the size of matrix:";

  15.               cin>>n;

  17.               int k;

  19.               cout<<"please input the 数乘的值：";

  21.               cin>>k;

  23.               int **matrix;

  25.               initma(n,matrix);//建立数组

  27.               meanma(n,matrix);//赋值

  29.               printma(n,matrix);

  31.               valuema(k,n,matrix);//求数乘

  33.               cout<<"the result of 数乘"<<endl;

  35.               printma(n,matrix);



  39.               LinkList list;

  41.               initList(n,list);

  43.               meanList(n,list);

  45.               printList(n,list);

  47.               valueList(k,n,list);

  49.               cout<<"the result of 数乘"<<endl;

  51.               printList(n,list);



  55. }
复制代码


【结果及截图】
答：运行程序，输入矩阵大小4，输入数乘的值2，（数组）按行列顺序输入矩阵赋值：5 3 1 4 8 9 6 4 2 8 6 3 0 1 4 5,输出矩阵初始赋值以及数乘后的结果如下：
1.002.jpg
（链表）按行列顺序输入矩阵赋值：5 3 1 4 8 9 6 4 2 8 6 3 0 1 4 5,输出矩阵初始赋值以及数乘后的结果如下：
1.003.jpg
【比较数组与链表】
在对于矩阵赋值、对矩阵进行数乘以及输出矩阵时，以数组形式存储的矩阵需要通过两层循环实现操作，而以链表来表示矩阵只需一层循环，相较之下，以链表表示矩阵，进行相关操作的效率更高。
【实验2】
【设计思路】
分别通过数组和链表实现矩阵的变换：
输入矩阵n*n的大小n，以及按行列顺序输入矩阵的赋值，回车输出矩阵转置的结果，根据提示输入旋转矩阵的角度x（90的倍数），回车输出矩阵顺时针旋转x度的结果，根据提示反射的方式（x或y），输入x或y后回车，输出矩阵反射的结果。
【数据输入】 输入矩阵的大小，矩阵的赋值，旋转的角度，反射的方式。
【数据输出】 矩阵的初始状态，矩阵转置、旋转、反射的结果。



1.004.jpg




【源程序实现】
【second.h】
  1. //链表操作

  3. typedef struct LNode{

  5.               int num;

  7.               LNode *next;

  9. }*LinkList,LNode;

  11. void initList(int n,LinkList &list);

  13. void meanList(int n,LinkList &list);

  15. void printList(int n,LinkList &list);

  17. void zhuanzhiList(int n,LinkList &list);

  19. void xuanzhuanList(int n,LinkList &list);

  21. void fansheList(int n,LinkList &list);



  25. //数组操作

  27. void initma(int n,int **&matrix);

  29. void meanma(int n,int **matrix);

  31. void printma(int n,int **matrix);



  35. void zhuanzhi(int n,int **matrix);



  39. void xuanzhuan(int n,int **matrix);



  43. void fanshe(int n,int **matrix);
复制代码

//其他
【second.cpp】
内容详见附件

【test.cpp】

  1. #include"second.h"

  3. #include"iostream"

  5. using namespace std;



  9. void main(){

  11.               int n;

  13.               cout<<"please input the size of matrix:";

  15.               cin>>n;

  17.             

  19.               //数组

  21.               int **matrix;

  23.               initma(n,matrix);//建立数组

  25.               meanma(n,matrix);//赋值

  27.               cout<<"please input 数组矩阵 in order:";



  31.               cout<<"the original state:"<<endl;

  33.               printma(n,matrix);

  35.               zhuanzhi(n,matrix);//转置



  39.               xuanzhuan(n,matrix);//旋转



  43.               fanshe(n,matrix);//反射





  49.               //链表

  51.               LinkList list;

  53.               cout<<"please input the size of matrix:";

  55.               cin>>n;

  57.               initList(n,list);

  59.               meanList(n,list);

  61.               LinkList p=list->next;

  63.               cout<<"please input 链表矩阵 in order:";

  65. /*              int i;

  67.               int rt=0;

  69.               for(i=0;i<16;i++){

  71.                             p->num=rt;

  73.                             rt++;

  75.                             p=p->next;

  77.               }*/



  81.               cout<<"the original state:"<<endl;

  83.               printList(n,list);

  85.               zhuanzhiList(n,list);

  87.               xuanzhuanList(n,list);

  89.               fansheList(n,list);

  91. }
复制代码
  1. #include"second.h"
  2. #include"iostream"
  3. using namespace std;

  5. //其他

  7. //数组操作
  8. void initma(int n,int **&matrix){
  9.         matrix=new int*[n];
  10.         int i;
  11.         for(i=0;i<n;i++){
  12.                 matrix[i]=new int[n];
  13.         }
  14. }

  16. void meanma(int n,int **matrix){
  17.         int i,j;
  18.         cout<<"please input 数组矩阵 in order:";
  19.         for(i=0;i<n;i++){
  20.                 for(j=0;j<n;j++){
  21.                         cin>>matrix[i][j];
  22.                 }
  23.         }
  24. }

  26. void printma(int n,int **matrix){
  27.         int i,j;
  28.         for(i=0;i<n;i++){
  29.                 for(j=0;j<n;j++){
  30.                         cout<<matrix[i][j]<<" ";
  31.                 }
  32.                 cout<<endl;
  33.         }       
  34. }

  36. void zhuanzhi(int n,int **matrix){
  37.         int i,j;
  38.         int t;
  39.         for(i=0;i<n;i++){
  40.                 for(j=i;j<n;j++){
  41.                         t=matrix[i][j];
  42.                         matrix[i][j]=matrix[j][i];
  43.                         matrix[j][i]=t;
  44.                 }
  45.         }
  46.         cout<<"the 转置 state:"<<endl;
  47.         printma(n,matrix);
  48. }

  50. void xuanzhuan(int n,int **matrix){
  51.         cout<<"please input 旋转度数(90 180 270 360...):";
  52.         int c;
  53.         cin>>c;

  55.         int num=(c/90)%4;
  56.         int x;
  57.         int i,j;
  58.         int t;

  60.         for(x=0;x<num;x++){
  61.                 for(i=0;i<n/2;i++){
  62.                         for(j=i;j<n-i-1;j++){
  63.                                 t=matrix[i][j];
  64.                                 matrix[i][j]=matrix[n-1-j][i];
  65.                                 matrix[n-1-j][i]=matrix[n-i-1][n-j-1];
  66.                                 matrix[n-i-1][n-j-1]=matrix[j][n-i-1];
  67.                                 matrix[j][n-i-1]=t;
  68.                         }
  69.                 }
  70.         }

  72.         cout<<"the 顺时针旋转 state:"<<endl;
  73.         printma(n,matrix);
  74. }
  75. void fanshe(int n,int **matrix){
  76.         char c;
  77.         cout<<"please choose x或y 反射:";
  78.         cin>>c;
  79.         int sign;
  80.         switch(c){
  81.         case 'x':sign=1;break;
  82.         case 'y':sign=0;break;
  83.         }
  84.         int i,j;
  85.         int t;
  86.         if(sign==1){
  87.                 for(j=0;j<n;j++){
  88.                         for(i=0;i<n/2;i++){
  89.                                 t=matrix[i][j];
  90.                                 matrix[i][j]=matrix[n-i-1][j];
  91.                                 matrix[n-1-i][j]=t;
  92.                         }
  93.                 }
  94.         }
  95.         else{
  96.                 for(i=0;i<n;i++){
  97.                         for(j=0;j<n/2;j++){
  98.                                 t=matrix[i][j];
  99.                                 matrix[i][j]=matrix[i][n-1-j];
  100.                                 matrix[i][n-1-j]=t;
  101.                         }
  102.                 }       

  104.         }

  106.         cout<<"the 反射 state:"<<endl;
  107.         printma(n,matrix);
  108. }

  110. //链表操作
  111. void initList(int n,LinkList &list){
  112.         int i;
  113.         list=new LNode;
  114.         list->num=1;
  115.         list->next=NULL;

  117.         LinkList p;
  118.         for(i=0;i<n*n;i++){
  119.                 p=new LNode;
  120.                 p->num=1;//初值定为1
  121.                 p->next=list->next;
  122.                 list->next=p;
  123.         }
  124. }

  126. void meanList(int n,LinkList &list){
  127.         LinkList p=list->next;
  128.         cout<<"please input 链表矩阵 in order:";
  129.         int i;
  130.         for(i=0;i<n*n;i++){
  131.                 cin>>p->num;
  132.                 p=p->next;
  133.         }
  134. }

  136. void printList(int n,LinkList &list){
  137.         LinkList p=list->next;
  138.         int i;
  139.         for(i=0;i<n*n;i++){
  140.                 cout<<p->num<<" ";
  141.                 p=p->next;
  142.                 if((i+1)%n==0)
  143.                         cout<<endl;
  144.         }
  145. }

  147. //小函数
  148. void inList(LinkList &e,LinkList &qian){//插入到qian之后
  149.         e->next=qian->next;
  150.         qian->next=e;
  151. }
  152. void outList(LinkList &e,LinkList &qian){//删除qian后的结点
  153.         e=qian->next;
  154.         qian->next=qian->next->next;
  155.         e->next=NULL;
  156. }

  158. void zhuanzhiList(int n,LinkList &list){
  159.         LinkList po=list->next,p=list->next;
  160.         int k,i,j;
  161.         LinkList e;
  162.         for(k=0;k<n-1;k++){

  164.         for(i=0;i<n-1;i++){
  165.                 for(j=1;j<n-k;j++){
  166.                         p=p->next;
  167.                 }
  168.                 outList(e,p);
  169.                 inList(e,po);
  170.                 po=po->next;
  171.         }
  172.         po=po->next;
  173.         p=po;
  174.         }
  175.         cout<<"the 转置 state:"<<endl;
  176.         printList(n,list);
  177. }

  179. void xuanzhuanList(int n,LinkList &list){
  180.         cout<<"please input 旋转度数(90 180 270 360...):";
  181.         int c;
  182.         cin>>c;

  184.         int num=(c/90)%4;
  185.         int x,i,j,k;
  186.         LinkList e;
  187.         LinkList p;
  188.         LinkList t;
  189.         for(x=0;x<num;x++){
  190.                 p=list;
  191.                 t=list->next;
  192.                 for(i=0;i<n;i++){
  193.                         t=p->next;
  194.                         for(k=0;k<n-1;k++){
  195.                         for(j=0;j<n-i-1;j++){
  196.                                 t=t->next;
  197.                         }
  198.                         outList(e,t);
  199.                         inList(e,p);
  200.                         }
  201.                         for(j=0;j<n;j++){
  202.                                 p=p->next;
  203.                         }
  204.                 }
  205.         }//x

  207.         cout<<"the 旋转 state:"<<endl;
  208.         printList(n,list);
  209. }

  211. void fansheList(int n,LinkList &list){
  212.         char ch;
  213.         cout<<"please choose x或y 反射:";
  214.         cin>>ch;
  215.         int sign;
  216.         switch(ch){
  217.         case 'x':sign=1;break;
  218.         case 'y':sign=0;break;
  219.         }
  220.         int i,j,k;
  221.         LinkList a,b,c,d;
  222.         LinkList p,t,e;
  223.         if(sign==1){//x反射 上下
  224.                 a=list;
  225.                 b=list;
  226.                 for(i=0;i<n;i++){
  227.                         b=b->next;
  228.                 }
  229.                 for(i=0;i<n-1;i++){
  230.                         c=b->next;
  231.                         d=b;
  232.                         for(j=0;j<n;j++){
  233.                                 d=d->next;       
  234.                         }
  235.                         b->next=d->next;
  236.                         d->next=a->next;
  237.                         a->next=c;
  238.                 }
  239.         }
  240.         else{//y反射  左右
  241.                 p=list;
  242.                 for(i=0;i<n;i++){
  243.                         t=p->next;
  244.                         for(j=0;j<n-1;j++){
  245.                                 outList(e,t);
  246.                                 inList(e,p);
  247.                         }
  248.                         for(k=0;k<n;k++){
  249.                                 p=p->next;
  250.                         }
  251.                 }

  253.         }

  255.         cout<<"the 反射 state:"<<endl;
  256.         printList(n,list);
  257. }



复制代码


评分

参与人数 1黑币 +100 收起 理由
admin + 100 共享资料的黑币奖励！

查看全部评分

回复

举报

ID:1 发表于 2017-3-17 16:45 | 显示全部楼层
好资料，51黑有你更精彩
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表