C++ cli 将矩阵定义为数组的数组，并在C+中计算其逆矩阵+； 遗憾的是我在C++方面没有太多的经验，我正在尝试在C++中进步。

首先，我定义了数组数组，这样我就形成了一个3x3矩阵：

array< array< double >^ >^ input = gcnew array< array< double >^ >(3);

for (j=0;j<input->Length;j++){
    input[j]=gcnew array<double>(3);

array^>^input=gcnewarray^>（3）；
对于（j=0；jLength；j++）{
输入[j]=gc新数组（3）；

然后我将矩阵元素分配给数组的输入数组：

 int value=1;
for(y=0;y<(3);y++){
  for(x=0;x<(3);x++)
 {input[y][x]=value;
  value=value+1;
  }
  }

int值=1；
对于（y＝0；y），C++中没有函数来进行矩阵运算，需要找到一些库来实现它或实现自己的.< /p>
请注意，对于固定大小的数组，可以使用常规C/C++数组，如下所示：

double arr[3][3];

<维基百科>有各种编程语言。如果你找的函数不可用，你也可以考虑在可用的FORTRAN或C或C++实现中写一个包装函数。
 < P>查看.< /P> < P>没有内置的C++函数来进行矩阵求逆（或任何其他矩阵计算）。
矩阵求逆的方法有很多

如果您想要效率和易于实施，那么
在C++ +/P>中，使用初等行变换求矩阵逆的最好的.< /P> < P>代码
#include<iostream>
#include<stdio.h>
#include<conio.h>
using
namespace std;

float a[4][4];float b[4][4]={{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}};
int no = 4;

int check(int k) {
    float cont = 0, cont2 = 0;
    for (int i = k; i < no; i++) {
        if (a[i][k] == 1) {
            for (int j = 0; j < no; j++) {
                cont = a[i][j];
                cont2 = b[i][j];
                a[i][j] = a[k][j];
                b[i][j] = b[k][j];
                a[k][j] = cont;
                b[k][j] = cont2;
            }
        } else if (a[i][k] == 0) {
            for (int j = 0; j < no; j++) {
                cont = a[i][j];
                cont2 = b[i][j];
                a[i][j] = a[no - 1][j];
                b[i][j] = b[no - 1][j];
                a[no - 1][j] = cont;
                b[no - 1][j] = cont2;
            }
        }
    }
    return 0;
}

int divi(int k) {
    float particular = a[k][k];
    for (int i = 0; i < no; i++) {
        a[k][i] = a[k][i] / particular;
        b[k][i] = b[k][i] / particular;
        if (a[k][i] == (-0)) {
            a[k][i] = 0;
        }
        if (b[k][i] == (-0)) {
            b[k][i] = 0;
        }
    }
    return 0;
}

int sub1(int k) {
    float particular;
    for (int j = k + 1; j < no; j++) {
        particular = a[j][k];
        for (int i = 0; i < no; i++) {
            a[j][i] = a[j][i] - (particular * a[k][i]);
            b[j][i] = b[j][i] - (particular * b[k][i]);
            if (a[j][i] == (-0)) {
                a[j][i] = 0;
            }
            if (b[j][i] == (-0)) {
                b[j][i] = 0;
            }
        }
    }
    return 0;
}

int sub2(int k) {
    float particular;
    for (int j = k - 1; j >= 0; j--) {
        particular = a[j][k];
        for (int i = no - 1; i >= 0; i--) {
            a[j][i] = a[j][i] - (particular * a[k][i]);
            b[j][i] = b[j][i] - (particular * b[k][i]);
            if (a[j][i] == (-0)) {
                a[j][i] = 0;
            }
            if (b[j][i] == (-0)) {
                b[j][i] = 0;
            }
        }
    }
    return 0;
}

int disp(){
 cout<<endl;
             for(int x=0;x<no;x++){
             for(int y=0;y<no;y++){
                   if(a[x][y]==(-0)){a[x][y]=0;}
                   if(b[x][y]==(-0)){b[x][y]=0;}
                   printf("%0.1f|||%0.1f     ",a[x][y],b[x][y]);
             }
             cout<<endl;}
}

int main()
{
    for(int i=0;i<no;i++){
          for(int j=0;j<no;j++){cout<<"Enter a["<<i<<"]["<<j<<"]";cin>>a[i}[j];}
          }
    for(int i=0;i<no;i++){
            for(int j=0;j<no;j++){cout<<a[i][j]<<" ";}
    cout<<endl;
          }

    for(int i=0;i<no;i++){
        check(i);
            disp();
        divi(i);
            disp();
        sub1(i);
            disp();
    }
    for(int i=no-1;i>=0;i--){
     sub2(i);
     disp();
     cout<<endl;
     }
     getch();
     getch();
     getch();
 return 0;}

 }

#包括
#包括
#包括
使用
名称空间标准；
浮点a[4][4]；浮点b[4][4]={{1,0,0,0}，{0,1,0,0}，{0,0,1,0}，{0,0,0,1}；
int no=4；
整数检查（整数k）{
浮点数cont=0，cont2=0；
for（int i=k；i=0；j--）{
特定=a[j][k]；
对于（int i=no-1；i>=0；i--）{
a[j][i]=a[j][i]（特别是*a[k][i]）；
b[j][i]=b[j][i]-（特别是*b[k][i]）；
如果（a[j][i]==（-0））{
a[j][i]=0；
}
如果（b[j][i]==（-0））{
b[j][i]=0；
}
}
}
返回0；
}
int disp（）{
coutI同意这一点。有大量的线性分析代码，其中大部分是Fortran语言，可以满足您的需要，没有比netlib.org上的Lapack更好的开始查找的地方了。我还建议不要使用数组数组范例。大多数外部代码都希望数组是一个按行适当设置的数字块或列主顺序。使用合适的索引运算符创建或查找类应该不会太困难。