帮忙做下流程图  谢啦


#ifndef PLURAL_HPP
#define PLURAL_HPP

//类名称：Plural 
//方法：GetR,GetI,SetRI,SetR,SetI
//数据：m_pluralR,m_pluralI 
class Plural
{
      public:
             Plural();
             Plural(float pR, float pI);
             ~Plural();
             float GetR() const;
             float GetI() const;
             void SetRI(float pR, float pI);
             void SetR(float pR);
             void SetI(float pI);
      private:
              float m_pluralR;
              float m_pluralI;
};


//名称: 复数乘法，PluralMul(Plural plural1, Plural plural2)
//参数：复数plural1 plural2 
//返回值：复数 
Plural PluralMul(Plural plural1, Plural plural2);


//函数名：复数除法，运算浮点数除以复数 
//参数：num，分子，是一个浮点数。den，分母，是一个复数 
//返回值：结果的复数 
Plural PluralDiv(float num, Plural den);


//函数名：复数求倒数 
//参数：den，分母，是一个复数 
//返回值：此复数的倒数 
Plural PluralDiv(Plural plu);


//参数：mat为待变换的复数矩阵的数组名，n为阶数 
//返回值：无 
//说明 ：变换后的结果依旧保存在mat中 
void MatrixInv(Plural *mat, int n);

#endif

/////////////////////////////////////////////////////////////////////////////////////////
#include "Plural.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 3
//类名称：Plural 
//方法：GetR,GetI,SetRI,SetR,SetI
//数据：m_pluralR,m_pluralI 
Plural::Plural()
{
    m_pluralR = 0;
    m_pluralI = 0;
}

Plural::Plural(float pR, float pI)
{
    m_pluralR = pR;
    m_pluralI = pI;                                        
}

Plural::~Plural(){}

float Plural::GetR() const
{
    return m_pluralR;
}

float Plural::GetI() const
{
    return m_pluralI;
}

void Plural::SetRI(float pR, float pI)
{
     m_pluralR = pR;
     m_pluralI = pI;
}

void Plural::SetR(float pR)
{
     m_pluralR = pR;
}

void Plural::SetI(float pI)
{
     m_pluralI = pI;
}


//  名称: 复数乘法，PluralMul(Plural plural1, Plural plural2)
//  参数：复数plural1 plural2 
//  返回值：复数 
Plural PluralMul(Plural plural1, Plural plural2)
{
       Plural result;
       result.SetRI(plural1.GetR() * plural2.GetR() - plural1.GetI() * plural2.GetI(),plural1.GetR() * plural2.GetI() + plural1.GetI() * plural2.GetR());
       return result;
}


//函数名：复数除法，运算浮点数除以复数 
//参数：num，分子，是一个浮点数。den，分母，是一个复数 
//返回值：结果的复数 
Plural PluralDiv(float num, Plural den)
{
       Plural result;
       float k;
       k = den.GetR() * den.GetR() + den.GetI() * den.GetI();
       result.SetR(num*den.GetR()/k);
       result.SetI(-1.0*num*den.GetI()/k);
       return result; 
}


//函数名：复数求倒数 
//参数：den，分母，是一个复数 
//返回值：此复数的倒数 
Plural PluralDiv(Plural plu)
{
       Plural result;
       float k;
       k = plu.GetR() * plu.GetR() + plu.GetI() * plu.GetI();
       result.SetR(plu.GetR()/k);
       result.SetI(plu.GetI()/k);  //此处原为“result.SetI(-1*plu.GetI()/k);”
       return result; 
}


//说明：以下3个函数组合用来求复数矩阵的逆。 
double *inv(double *A,double *Ainv,int n);
void mulAB(double *A,double *B,double *C,int am,int an,int bm,int bn);
//参数：mat为待变换的复数矩阵的数组名，n为阶数 
//返回值：无 
//说明 ：变换后的结果依旧保存在mat中 
void MatrixInv(Plural *mat, int n);

//矩阵求逆。A为原矩阵，Ainv为求逆之后矩阵，n为阶数 
double *inv(double *A, double *Ainv, int n)
{ 
  int *is, *js, i, j, k, l, u, v;
  double d, p;
  
  for (i=0; i<n*n; i++)
  *(Ainv+i) = *(A+i);
  
  is = (int*)malloc(n*sizeof(int));
  js = (int*)malloc(n*sizeof(int));
  
  for (k=0; k<=n-1; k++)
  { 
    d=0.0;
    for (i=k; i<=n-1; i++)
    for (j=k; j<=n-1; j++)
    { 
        l = i*n+j; 
        p = fabs(Ainv[l]);
        if (p>d) 
        { 
            d = p; 
            is[k] = i; 
            js[k] = j;
        }
    }
    
    if (d + 1.0 == 1.0)
    { 
        free(is); 
        free(js); 
        return NULL;
    }
    
    if (is[k] != k)
       for (j=0; j<=n-1; j++)
       { 
           u = k*n+j; 
           v = is[k] * n + j;
           p = Ainv[u]; 
           Ainv[u] = Ainv[v]; 
           Ainv[v] = p;
       }
    
    if (js[k] != k)
       for (i=0; i<=n-1; i++)
       { 
           u = i * n + k; 
           v = i * n + js[k];
           p = Ainv[u]; 
           Ainv[u] = Ainv[v]; 
           Ainv[v] = p;
       }
    
    l = k * n + k;
    
    Ainv[l] = 1.0 / Ainv[l];
    
    for (j=0; j<=n-1; j++)
        if (j != k)
        { 
            u = k * n + j; 
            Ainv[u] = Ainv[u] * Ainv[l];
        }
    
    for (i=0; i<=n-1; i++)
        if (i != k)
            for (j=0; j<=n-1; j++)
            if (j != k)
            { 
                u = i * n + j;
                Ainv[u] = Ainv[u] - Ainv[i*n+k] * Ainv[k*n+j];
            }
    
    for (i=0; i<=n-1; i++)
    if (i != k)
    { 
        u = i * n + k; 
        Ainv[u] = -Ainv[u] * Ainv[l];}
    }
    
    for (k=n-1; k>=0; k--)
    { 
        if (js[k]!=k)
        for (j=0; j<=n-1; j++)
        { 
            u = k*n+j; 
            v = js[k] * n + j;
            p = Ainv[u]; 
            Ainv[u] = Ainv[v]; 
            Ainv[v] = p;
        }
    
    if (is[k] != k)
    for (i=0; i<=n-1; i++)
    { 
        u = i * n + k; 
        v = i * n + is[k];
        p = Ainv[u]; 
        Ainv[u] = Ainv[v]; 
        Ainv[v] = p;
    }
  }
  
  free(is); 
  free(js);
  
  return Ainv;
}

//参数：a为原矩阵，b为逆矩阵，c为结果。其他在此都为n 
void mulAB(double *a, double *b, double *c, int am, int an, int bm, int bn)
{ 
 int i, j, l, u;
  if (an != bm) 
  {
     printf("不能完成原矩阵和其逆矩阵矩阵相乘\n");
     return;
  } 
  
  for (i=0; i<am; i++)
  for (j=0; j<bn; j++)
  { 
      u=i*bn+j;
      c[u]=0.0;
      for (l=0; l<an; l++)
      c[u]=c[u]+a[i*an+l]*b[l*bn+j];
  }
  return;
}

//复数矩阵求逆。参数：mat为待求矩阵，n为阶数 
void MatrixInv(Plural *mat,int n) 
{ 
    int i, j;
    double pluralR[N][N], pluralI[N][N];
    double *a = NULL, *b = NULL, *c = NULL;
    double *resultR = NULL, *resultI = NULL;
    Plural result[N][N];
    
    for (i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
        {
            pluralR[i][j] = mat[i*n+j].GetR();
            pluralI[i][j] = mat[i*n+j].GetI();
        }
    }
    
    printf("原始矩阵为:\n");
    for(i=0;i<n;i++)
    {
       for(j=0;j<n;j++) 
           printf("%10.4f + j%0.4f\t", (*pluralR)[i*n+j],(*pluralI)[i*n+j]);
           printf("\n");
    }  
      
    a = (double*)malloc(n*n*sizeof(double));
    b = (double*)malloc(n*n*sizeof(double));
    c = (double*)malloc(n*n*sizeof(double));
    
    resultR = inv(*pluralR,a,n);
    resultI = inv(*pluralI,b,n);
    
    if (resultI != NULL)
    {
        printf("\n求逆之后逆矩阵是:\n");
        if (n%2 == 0)
        {
            for (i=0; i<n; i++)
            {   
                for (j=0; j<n; j++)
                    printf("%10.4f + j%0.4f\t", resultR==NULL? 0:resultR[i*n+j], resultI==NULL ? 0:resultI[i*n+j]);
                printf("\n");
            }
        }
        else
        {
            for (i=0; i<n; i++)
            {   
                for (j=0; j<n; j++)
                    printf("%10.4f + j%0.4f\t", resultR==NULL? 0:resultR[i*n+j], resultI==NULL ? 0:-1*resultI[i*n+j]);
                printf("\n");
            }
        }
        
//      测试所求实部逆矩阵 
//       mulAB(*pluralR,a,c,n,n,n,n);
//       printf("\n\n求逆后原实部和现在的实部乘积是\n");
//       for(i=0;i<n;i++)
//       {   
//           for(j=0;j<n;j++)
//              printf("%10.4f\t", c[i*n+j]);
//           printf("\n");
//       } 

 //      测试用所求逆矩阵 
//       mulAB(*pluralI,b,c,n,n,n,n);
//       printf("\n\n求逆之后原虚部和现在的虚部乘积是:\n");
//      for (i=0; i<n; i++)
//       {   
//           for (j=0; j<n; j++)
//              printf("%10.4f\t", -1.0*c[i*n+j]);
//           printf("\n");
//       }  
   }
    
    for (i=0; i<n; i++)
    {
        for (j=0; j<n; j++)
        mat[i*n+j].SetRI(resultR == NULL ? 0:resultR[i*n+j], resultI == NULL ? 0:resultI[i*n+j]);
    }  
    
    free(a);
    free(b);
    free(c);   

}
/////////////////////////////////////////////////
#include <iostream>
#include "Plural.h"

using namespace std;

int main()
{
    Plural matrix2[3][3];
    
    matrix2[0][0].SetRI(0,-26.666666);matrix2[0][1].SetRI(0,10);
    matrix2[0][2].SetRI(0,10);
    matrix2[1][0].SetRI(0,10);matrix2[1][1].SetRI(0,-33.333333);
   matrix2[1][2].SetRI(0,10);
    matrix2[2][0].SetRI(0,10);matrix2[2][1].SetRI(0,10);
    matrix2[2][2].SetRI(0,-20);

    MatrixInv(*matrix2,3);
    
    printf("\n1点短路电流是\n");     
    printf("%f + j%f",PluralDiv(matrix2[0][0]).GetR(), PluralDiv(matrix2[0][0]).GetI());

    printf("\n2点短路电流是\n");     
    printf("%f + j%f",PluralDiv(matrix2[1][1]).GetR(), PluralDiv(matrix2[1][1]).GetI());

    printf("\n3点短路电流是\n");     
    printf("%f + j%f",PluralDiv(matrix2[2][2]).GetR(), PluralDiv(matrix2[2][2]).GetI());
    
    getchar();
    return 0;
}