1

我正在开发一些用于处理矩阵的测试代码。在代码中，矩阵由一个类定义，该类具有用于乘法矩阵等的各种函数。我在编译时遇到了关于预期初始化程序的困难。你能指出我在这个问题上的正确方向吗？

#include <iostream> 
#include <math.h>
#include <iomanip>

#define Column_Spacing 10;

using namespace std;

class Matrix{
    public: 
        void Output_Matrix(double **, int, int);
        double** Zero_Matrix(int);
        double** Input_Matrix(int);
        void Calculate_Minor(double **, double **, int, int, int);
        double Determinant (double **, int);
        void Matrix_Inversion(double **, double **, int);
};

/*******************************************************************************
function: output matrix

This function is used to output a matrix of arbitrary size. It requires three
arguments: the matrix/matrix location, the number of rows in the matrix and the
number of columns in the matrix.
*******************************************************************************/

void Output_Matrix(double **Matrix, int Number_of_Rows, int Number_of_Columns){
    int Rows_Output_Iterator = 0, Columns_Output_Iterator = 0;
    while (Rows_Output_Iterator < Number_of_Rows){
        while (Columns_Output_Iterator < Number_of_Columns){
            cout << "/t" << Matrix [Rows_Output_Iterator][Columns_Output_Iterator];
            Columns_Output_Iterator++;
        }
        cout << endl;
        Columns_Output_Iterator = 0;
        Rows_Output_Iterator++;
    }
}

/*******************************************************************************
function: zero matrix

This function is used to create an arbitrary-sized matrix in which all of its
elements are zero.
*******************************************************************************/

double** Zero_Matrix(int Matrix_Order){
    int Number_of_Rows_Zero, Number_of_Columns_Zero;
    if (Matrix_Order > 0){
        Number_of_Rows_Zero = Matrix_Order;
        Number_of_Columns_Zero = Matrix_Order;
    }
    else{
        cout << "Zero Matrix." << endl;
        cout << "State the number of rows in the zero matrix: ";
        cin >> Number_of_Rows_Zero;
        cout << "State the number of columns in the zero matrix: ";
        cin >> Number_of_Columns_Zero;
    }
    double **Zero_Matrix = new double*[Number_of_Rows_Zero];
    for (int Zero_Matrix_Iterator = 0; Zero_Matrix_Iterator < Number_of_Rows_Zero; Zero_Matrix_Iterator++){
        Zero_Matrix[Zero_Matrix_Iterator] = new double[Number_of_Columns_Zero];
    }
    for (int Row_Iterator = 0; Row_Iterator < Number_of_Rows_Zero; Row_Iterator++){
        for (int Column_Iterator = 0; Column_Iterator < Number_of_Columns_Zero; Column_Iterator++){
            Zero_Matrix[Row_Iterator][Column_Iterator] = 0;
        }
    }
    return Zero_Matrix;
}

/*******************************************************************************
function: input matrix

This function is used to create an arbitrary-sized matrix defined by the used
and to fill it with arbitrary entries specified by the user.
*******************************************************************************/

double** Input_Matrix(int Matrix_Order){
    int Number_of_Rows, Number_of_Columns;
    double Entry;
    cout << "Input Matrix A." << endl;
    if (Matrix_Order > 0){
        Number_of_Rows = Matrix_Order;
        Number_of_Columns = Matrix_Order;
    }
    else{
        cout << "State the number of rows in the matrix: ";
        cin >> Number_of_Rows;
        cout << "State the number of columns in the matrix: ";
        cin >> Number_of_Columns;
    }
    double **Matrix_A = new double*[Number_of_Rows];
    for (int Iterator = 0; Iterator < Number_of_Rows; Iterator++){
        Matrix_A[Iterator] = new double[Number_of_Columns];
    }
    cout << "Entry ij" << endl;
    for (int Row_Iterator = 0; Row_Iterator < Number_of_Rows; Row_Iterator++){
        for (int Column_Iterator = 0; Column_Iterator < Number_of_Columns; Column_Iterator++){
            cout << "Entry " << Row_Iterator << Column_Iterator << ": ";
            cin >> Entry;
            Matrix_A [Row_Iterator][Column_Iterator] = Entry;
        }
    }
    cout << "Matrix A = " << endl;
    Output_Matrix(Matrix_A, Number_of_Rows, Number_of_Columns);
    return Matrix_A;
}

/*******************************************************************************
function: calculate minor

This function calculates the minor of an arbitrary input matrix. This function
requires five arguments: the input matrix, the minor (to store the output
value), the row number (which will be eliminated from the input matrix), the
column number which will be eliminated from the input matrix and the order of
the matrix respectively. 
*******************************************************************************/

void Calculate_Minor(double **Matrix, double **Minor, int Row_Number, int Column_Number, int Matrix_Order){
    int Row_Count = 0, Column_Count = 0;
    for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
        if (Row_Iterator != Row_Number){
            Column_Count = 0;
            for(int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
                if (Column_Iterator != Column_Number){
                    Minor[Row_Count][Column_Count] = Matrix[Row_Iterator][Column_Iterator];
                    Column_Count++;
                }
            }
            Row_Count++;
        }
    }
}

/*******************************************************************************
function: determinant

This function calculates the determinant of an arbitrary sized input matrix.
This function requires two arguments/inputs which are the input matrix and the
order of the matrix respectively. This function uses recursion i.e. the function
can, if necessary, be called again suppling the corresponding minors of the
original input matrix until the total determinant has been calculated. This
function requires the use of the function Calculate_Minor.
*******************************************************************************/

double Determinant (double **Matrix, int Matrix_Order){
    double det = 0;
    if (Matrix_Order == 1){
        return Matrix[0][0];
    }
    double **Minor_Matrix = new double*[Matrix_Order - 1];
    for (int Iterator = 0; Iterator < Matrix_Order - 1; Iterator++){
        Minor_Matrix[Iterator] = new double[Matrix_Order - 1];
    }
    for (int Column_Iterator = 0; Column_Iterator <= (Matrix_Order - 1); Column_Iterator++){
        Calculate_Minor(Matrix, Minor_Matrix, 0, Column_Iterator, Matrix_Order);
        det += (Column_Iterator % 2 == 1?-1.0:1.0)*Matrix[0][Column_Iterator]*Determinant(Minor_Matrix, Matrix_Order - 1);
        //det += pow(-1, Iterator_2)*Matrix[0][Iterator_2]*Determinant(Minor, Matrix_Size - 1);
    }
    for (int Iterator = 0; Iterator < (Matrix_Order - 1); Iterator++){
        delete [] Minor_Matrix[Iterator];
    }
    delete [] Minor_Matrix;
    //cout << "det = " << det << endl;
    return det;
}

/*******************************************************************************
function: matrix inversion

This function calculates the inverse of an arbitrary input matrix. This function
requires three arguments/inputs which are the input matrix, the cofactor matrix
(somewhere to store the cumulative output of this function for example a matrix
whose entries are all zero) and the order of the matrix respectively. This
function uses the determinant function and the Calculate_Minor function. 
*******************************************************************************/

void Matrix_Inversion(double **Matrix, double **Cofactor_Matrix, int Matrix_Order){
    if (Determinant(Matrix, Matrix_Order) == 0){
        cout << "The matrix is singular i.e. det(A) = 0 hence, no inverse matrix (A^-1) exists." << endl;
    }
    else{
        double Coefficient = 1/(Determinant(Matrix, Matrix_Order));
        double *Temporary = new double[(Matrix_Order - 1)*(Matrix_Order - 1)];
        double **Minor = new double*[Matrix_Order - 1];
        for (int Iterator = 0; Iterator < (Matrix_Order - 1); Iterator++){
            Minor[Iterator] = Temporary + (Iterator*(Matrix_Order - 1));
        }
        for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
            for (int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
                Calculate_Minor(Matrix, Minor, Row_Iterator, Column_Iterator, Matrix_Order);
                Cofactor_Matrix[Row_Iterator][Column_Iterator] = Determinant(Minor, Matrix_Order - 1);
                if ((Row_Iterator + Column_Iterator)%2 == 1){
                    Cofactor_Matrix[Row_Iterator][Column_Iterator] = -Cofactor_Matrix[Row_Iterator][Column_Iterator];
                }
            }
        }
    double **Cofactor_Transpose = new double*[Matrix_Order];
    for (int Iterator = 0; Iterator < Matrix_Order; Iterator++){
        Cofactor_Transpose[Iterator] = new double[Matrix_Order];
    }
    for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
        for (int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
            Cofactor_Transpose[Column_Iterator][Row_Iterator] = Cofactor_Matrix[Row_Iterator][Column_Iterator];
        }
    }
    double **Inverse_Matrix = new double*[Matrix_Order];
    for (int Iterator = 0; Iterator < Matrix_Order; Iterator++){
        Inverse_Matrix[Iterator] = new double[Matrix_Order];
    }
    for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
        for (int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
            Inverse_Matrix[Column_Iterator][Row_Iterator] = Coefficient*Cofactor_Matrix[Row_Iterator][Column_Iterator];
        }
    }
    cout << "(Inverse Matrix) A^-1 = " << Coefficient << endl;
    Output_Matrix(Cofactor_Transpose, Matrix_Order, Matrix_Order);
    cout << "= " << endl;
    Output_Matrix(Inverse_Matrix, Matrix_Order, Matrix_Order);
    delete [] Temporary;
    delete [] Minor;
    delete [] Cofactor_Transpose;
    delete [] Inverse_Matrix;
}
}

int main(){
    int Matrix_Order = 0;
    cout << "Define the order of the input matrix (... if the input matrix is square - if not, set this variable to zero): ";
    cin >> Matrix_Order;
    Matrix Matrix_A, Cofactor_Matrix, determinant, Matrix_Inverse;
    double **Matrix_A.Input_Matrix(Matrix_Order);
    /*
    double **Cofactor_Matrix.Zero_Matrix(Matrix_Order);
    double det = determinant.Determinant(Matrix_A, Matrix_Order);
    cout << "(Determinant) det = " << det << endl;
    Matrix_Inverse.Matrix_Inversion(Matrix_A, Cofactor_Matrix, Matrix_Order);
    */
    return 0;
}
4

1 回答 1

3

从你的类定义：

class Matrix{
public: 
    void Output_Matrix(double **, int, int);
    double** Zero_Matrix(int);
    double** Input_Matrix(int);
    void Calculate_Minor(double **, double **, int, int, int);
    double Determinant (double **, int);
    void Matrix_Inversion(double **, double **, int);
};

而不是您实现的方法中的这一行：

void Output_Matrix(double **Matrix, int Number_of_Rows, int Number_of_Columns){ ... }

您应该编写以下内容：

void Matrix::Output_Matrix(double **Matrix, int Number_of_Rows, int Number_of_Columns){...}

您必须Matrix::像我一样添加到您的每个班级成员实现中。

在你的main，你写了这一行：

double **Matrix_A.Input_Matrix(Matrix_Order);

这是没有意义的。我建议你使用std::vector<std::vector<double> >而不是double**. 然后你可以写：typedef std::vector<std::vector<double> > MATRIX;。

例如，您的 main 中的行将是 : MATRIX M = Matrix_A.Input_Matrix(Matrix_Order);。

C++ 中关于 std::vector 的实用程序

让我们为您的Input_Matrix方法举一个例子：

MATRIX Matrix::Input_Matrix(int Matrix_Order){
    int Number_of_Rows, Number_of_Columns;
    double Entry;
    cout << "Input Matrix A." << endl;
    if (Matrix_Order > 0){
        Number_of_Rows = Matrix_Order;
        Number_of_Columns = Matrix_Order;
    }
    else{
        cout << "State the number of rows in the matrix: ";
        cin >> Number_of_Rows;
        cout << "State the number of columns in the matrix: ";
        cin >> Number_of_Columns;
    }
    MATRIX Matrix_A;
    Matrix_A.resize(Number_of_Rows); 
    for (int Iterator = 0; Iterator < Number_of_Rows; Iterator++){
        Matrix_A[Iterator].resize(Number_of_Columns);
    }
    cout << "Entry ij" << endl;
    for (int Row_Iterator = 0; Row_Iterator < Number_of_Rows; Row_Iterator++){
        for (int Column_Iterator = 0; Column_Iterator < Number_of_Columns; Column_Iterator++){
            cout << "Entry " << Row_Iterator << Column_Iterator << ": ";
            cin >> Entry;
            Matrix_A[Row_Iterator][Column_Iterator] = Entry;
        }
    }
    cout << "Matrix A = " << endl;
    /* First parameter of the following method must be of type MATRIX. */
    Output_Matrix(Matrix_A, Number_of_Rows, Number_of_Columns); 

    return Matrix_A;
}

现在，您将能够按照此示例完成其余的工作。希望这会帮助你。

于 2013-11-12T16:38:47.207 回答