C++高级语言程序设计.docx

C++高级语言程序设计.docx

《C++高级语言程序设计.docx》由会员分享，可在线阅读，更多相关《C++高级语言程序设计.docx（10页珍藏版）》请在冰豆网上搜索。

C++高级语言程序设计

《高级语言程序设计》

课程设计报告

专    业：

班    级：

姓    名：

学    号：

设计题目：

    矩阵运算软件

指导老师：

目      录

1、课程涉及题目及设计目标…………………………3

2、设计思想……………………………………………3

3、类及对象设计………………………………………3

4、程序代码……………………………………………4

5、调试记录…………………………………………15

6、致谢………………………………………………16

7、总结………………………………………………16

1、课程设计题目描述、要求及设计目标：

（1）课程设计题目描述、要求:

自定义矩阵matrix类型，在其中重载如下几个可用来实现矩阵加、矩阵减、矩阵乘、矩阵除、矩阵转置、矩阵赋值的运算符“+”、“-”、“*”、“~”、“=”，以及用于完成矩阵输入输出的运算符“>>”和“<<”（其中涉及到的各输入矩阵的大小均有用户动态决定）。

进一步，参照参考书上自定义类Matrix的实现方法（该类用来求出具有lines行的满秩矩阵的逆矩阵），再将求逆运算添加进去。

即是说，可进一步增加用来实现矩阵求逆的重载运算符“！

”。

如，voidoperator!

（）;（用于求出矩阵的逆，并使解处于对象的MatrA矩阵的右半部分。

并编制主函数，通过不同对象对各种重载运算符进行使用以验证他们的正确性）。

（2）课程设计目标：

  运用矩阵运算软件，实现矩阵的求和、求差、求积、转置、求逆等运算。

2、设计思想：

首先要熟练掌握矩阵加、矩阵乘、矩阵转置、矩阵求逆等与矩阵相关的求解方法并能写出相关程序代码。

其次要会利用运算符重载的方式将这些运算组合到一起以形成一个自定义的类matrix，而且要对这些运算符使用类成员的方式进行重载（而不使用友元形式）。

最后，还要学会重载用于完成矩阵输入/输出的运算符“>>”和“<<”（重载这两个运算符有些特殊，通常使用友元方式来进行，而且大都使用类似于如下的重载格式：

friendistream&operator>>（istreamin,matrix&matr）；和friendostream&operator<<（ostreamout,matrix&matr）。

其中的“operator>>”完成从istream类的流对象in上（如对应实参可为cin,及指定从键盘上）输入matr矩阵的数据，而“operator<<”则用于实现在ostream类的流类对象out上（如对应实参可为cout,即指定在屏幕上）输出矩阵matr的有关数据。

3、类及对象设计：

建立一个matrix类，包含mem，matr，lines，MatrA等数据成员，以及matrix（matrix&matr），matrix:

:

~matrix（），matrix（）等成员函数，还有友元函数。

并且重载“+”、“-”、“*”、“<<”和“>>”等运算符，使之能用于输出以上类与对象，最终实现简单的矩阵的求和、求差、求积、转置、求逆等运算。

4、程序代码如下：

#include

#include

#include

classmatrix

{

  intr,c;

  float**mem;

  floatmatr;

  intlines;

  double**MatrA;

  floatgetElem（inta,intb）;

  voidsetElem（inta,intb,floatf）;

  friendistream&operator>>（istream&in,matrix&matr）;

  friendostream&operator<<（ostream&out,matrix&matr）;

public:

  intgetr（）;

  intgetc（）;

  matrix（inta,intb）;

  matrix（）;

  matrix（intLns）;

  matrix（matrix&matr）;

  matrix:

:

~matrix（）;

  matrixoperator+（matrix&）;

    matrixoperator-（matrix&）;

  matrixoperator*（matrix&）;

  voidoperator=（matrix&）;

  matrixoperator~（）;

  voidoperator!

（）;

  voidInSourceMatrix（）;

  voidprintMatrix（）;

  voidprintSourceMatrix（）;

  voidprintResultMatrix（）;

};

matrix:

:

matrix（inta,intb）

{

  r=a;

  c=b;

  mem=newfloat*[r];

  for（inti=0;i

      *（mem+i）=newfloat[c];

  MatrA=NULL;

}

matrix:

:

matrix（）

{

  r=1;

  c=1;

  mem=NULL;

  MatrA=NULL;

}

matrix:

:

matrix（matrix&matr）

{

  r=matr.r;

  c=matr.c;

  mem=newfloat*[r];

  for（inti=0;i

          *（mem+i）=newfloat[c];

  for（i=0;i

      for（intj=0;j

          setElem（i,j,matr.getElem（i,j））;

      MatrA=NULL;

}

matrix:

:

~matrix（）

{

  if（mem）

  {

      for（inti=0;i

          delete[]mem;

          delete[]mem;

  }

  if（MatrA）

  {

  for（inti=0;i

      delete[]MatrA;

  delete[]MatrA;

  }

}

floatmatrix:

:

getElem（inta,intb）

{

  returnmem[a];

}

intmatrix:

:

getr（）

{

  returnr;

}

intmatrix:

:

getc（）

{

  returnc;

}

voidmatrix:

:

setElem（inta,intb,floatf）

{

  mem[a]=f;

}

istream&operator>>（istream&in,matrix&matr）

{

cout<<"Pleaseinputr（row）andc（column）:

";

in>>matr.r>>matr.c;

matr.mem=newfloat*[matr.r];

for（inti=0;i

*（matr.mem+i）=newfloat[matr.c];

cout<<"Pleaseinput"<

"<

for（i=0;i

for（intj=0;j

in>>matr.mem[j];

returnin;

}

ostream&operator<<（ostream&out,matrix&matr）

{

  out.precision

（2）;

  out<

:

fixed）;

  for（inti=0;i

  {

      out<<"{";

      for（intj=0;j

      {

          out.width（10）;

          out<

          if（j

            out<<",";

      }

      out<<"}";

      out<

  }

  returnout;

}

matrixmatrix:

:

operator+（matrix&matr）

{

  if（r!

=matr.getr（）||c!

=matr.getc（））

  {

      cout<

--row1!

=row2||col1!

=col2"<

      exit（0）;

  }

  matrixres（r,c）;

  for（inti=0;i

      for（intj=0;j

          res.setElem（i,j,getElem（i,j）+matr.getElem（i,j））;

          returnres;

}

matrixmatrix:

:

operator-（matrix&matr）

  {

  if（r!

=matr.getr（）||c!

=matr.getc（））

  {

      cout<

--row1!

=row2||col1!

=col2"<

      exit（0）;

  }

  matrixres（r,c）;

  for（inti=0;i

      for（intj=0;j

          res.setElem（i,j,getElem（i,j）-matr.getElem（i,j））;

          returnres;

}

matrixmatrix:

:

operator*（matrix&matr）

{

  if（c!

=matr.getr（））

  {

      cout<

--col1!

=row2"<

      exit（0）;

  }

      matrixres（r,matr.getc（））;

          for（inti=0;i

            for（intj=0;j

            {

                floattemp=0;

                  for（intk=0;k

                    temp+=mem[k]*matr.getElem（k,j）;

                    res.setElem（i,j,temp）;

            }

          returnres;

}

voidmatrix:

:

operator=（matrix&matr）

{

  r=matr.r;

  c=matr.c;

  mem=newfloat*[r];

    for（inti=0;i

      *（mem+i）=newfloat[c];

  for（i=0;i

      for（intj=0;j

        setElem（i,j,matr.getElem（i,j））;

}

matrixmatrix:

:

operator~（）

{

  if（c!

=r）

  {

      cout<

--col!

=row"<

      exit（0）;

  }

  matrixres（c,r）;

  for（inti=0;i

      for（intj=0;j

          res.setElem（i,j,mem[j]）;

          returnres;

}

matrix:

:

matrix（intLns）

{

  lines=Lns;

  MatrA=newdouble*[lines];

    for（inti=0;i

  MatrA=newdouble[2*lines];

  mem=NULL;

}

voidmatrix:

:

InSourceMatrix（）

{

  inti,j;

  for（i=0;i

      for（j=0;j

          cin>>MatrA[j];

          for（i=0;i

      for（j=lines;j<2*lines;j++）

      MatrA[j];

      intind=lines;

      for（i=0;i

          MatrA[ind++]=1;

}

voidmatrix:

:

printMatrix（）

{

  for（inti=0;i

  {

      for（intj=0;j<2*lines;j++）

          cout<

      cout<

  }

}

voidmatrix:

:

printSourceMatrix（）

{

  for（inti=0;i

  {

      for（intj=0;j

          cout<

      cout<

  }

}

voidmatrix:

:

printResultMatrix（）

{

  for（inti=0;i

  {

      for（intj=lines;j<2*lines;j++）

      cout<

      cout<

  }

}

voidmatrix:

:

operator!

（）

{

  intk,i,j;

  for（k=1;k

  {

      for（i=k;i

      {

          doublefactor=-MatrA[k-1]/MatrA[k-1][k-1];

          for（j=k-1;j<2*lines;j++）

            MatrA[j]+=MatrA[k-1][j]*factor;

      }

  }

  //printMatrix（）

  for（i=0;i

  {

      doublefactor=MatrA;

      for（j=i;j<2*lines;j++）

            MatrA[j]/=factor;

  }

  //printMatrix（）

  for（k=lines-2;k>=0;k--）

  {

      for（i=k;i>=0;i--）

      {

            doublefactor=-MatrA[k+1];

            for（j=k+1;j<2*lines;j++）

            MatrA[j]+=（factor*MatrA[k+1][j]）;

      }

  }

}

voidmain（）

{

  charchoose;

  matrixx,y;

  do

  {

      cout<<"矩阵运算，请选择"<

      cout<<"--------------------------"<

      cout<<"1.求和;2.求差;3.求积;4.转置;5.求逆;6.退出"<

      cin>>choose;

  }

  while（choose<'1'||choose>'6'）;

  if（choose=='6'）

      exit（0）;

  if（choose==5）

  {

      cout<<"InputLINES:

";

      intlines;

      cin>>lines;

      matrixmatr1（lines）;

      cout<<"Input"<

"<

      matr1.InSourceMatrix（）;

      cout<<"---Thesourcematrixis---"<

      matr1.printSourceMatrix（）;

      !

matr1;

      cout<<"---TheresultMatrixis---"<

      matr1.printResultMatrix（）;

  }

  else

  {

      cout<<"Pleaseinputthefirstmatrix--x"<

      cin>>x;

      cout<<"-------x=-------"<

      cout<

      if（choose<'4'）

      {

          cout<<"Pleaseinputthesecondmatrix--y"<

      cin>>y;

      cout<<"-------y=-------"<

      cout<

      }

      switch（choose）

      {

      case'1':

          {

            matrixr;

            r=x+y;

            cout<<"-------r=x+y-------"<

              cout<

            break;

          }

          case'2':

          {

            matrixr;

            r=x-y;

            cout<<"-------r=x-y-------"<

              cout<

            break;

          }

          case'3':

          {

            matrixr;

            r=x*y;

            cout<<"-------r=x*y-------"<

              cout<

            break;

          }

          case'4':

          {

            matrixr;

            r=~x;

            cout<<"-------r=~x=-------"<

              cout<

            break;

          }

      }

  }

}

5、调试记录如下:

由于编程水平有限，程序运行过程出现不少错误。

但是在老师、同学以及参考文献的耐心帮助下，所有的错误都一点点儿的被找出来了。

以下是部分当时的调试记录。

（1）、在matrix类的定义中对于成员函数的定义往往丢掉逗号。

例如：

“matrixoperator+（matrix&）;”被错写为“matrixoperator+（matrix&）”。

（2）、在matrix类的定义中对于成员函数的定义应该用“void”开头的，却错用“int”开头。

例如：

“voidprintSourceMatrix（）;”被错写为“intprintSourceMatrix（）;”。

（3）、由于程序较长，整个类的定义或者主函数往往不在一页上，所以经常出现漏掉一对大括号中的“}”的现象。

（4）、在写程序过程容易出现大小写错误，导致后来“自创的”的变量变成未声明的。

例如：

“MatrA=NULL;”被错写为“MatrA=Null;”,造成“Null”变成“自创的”未声明的变量。

（5）、运用指针变量的地方往往容易溜掉其前的“*”。

例如：

“*（mem+i）=newfloat[c];”被错写为“（mem+i）=newfloat[c];”。

（6）、由于在写程序过程中可能运用中英文切换，所以有时候标点符号是在中文条件下输入的，从而导致程序出错。

例如：

“cout<<"矩阵运算，请选择"<

（7）、定义某些特殊变量时，往往要特别认真，否则就跳进了错误的陷阱。

例如：

“float**mem