c++ - C++中的矩阵类？

Question

我一直在尝试编写一个 Matrix 类，并且我正在使用一个 main 方法来测试它。它根本不起作用。

我不明白为什么 size(allRowValues 的大小除以 double 的大小)为零!

我一直在写一些调试打印，但它没有帮助...我真的是 C++ 的新手，所以任何帮助/建议都将不胜感激。

 1 #include "matrix.h"
 2 #include <iostream>
 3 #include <sstream>
 4 
 5 Matrix::Matrix(){
 6 };
 7 
 8 Matrix::Matrix(int rows, int columns, double allRowValues [] ){
 9     this->rows = rows;
10     this->columns = columns;
11     this->matrixValues = new double[rows*columns];
13     std::cout <<"ALL ROW VALUES" <<std::endl;
14     std::cout<<"*****" <<std::endl;
15     std::cout << sizeof (allRowValues) << std::endl;
16     std::cout<<"*****" <<std::endl;
17     std::cout << sizeof(allRowValues[0]) << std::endl;
18     std::cout<<"*****" <<std::endl;
19     int size = sizeof(allRowValues)/sizeof(double);
20     int numberOfValues = rows * columns;
21     int currentIndex = 0;
22     for (int i = 0; i < numberOfValues; i++){
23             std::cout<< "MATRIX CONSTRUCTOR\n";
24             std::cout<<allRowValues <<std::endl;
25             std::cout<<"-----"<<std::endl;
26             std::cout<<index << std::endl;
27             std::cout<<"-----"<<std::endl;
28             std::cout<<size << std::endl;
29             std::cout<<"-----"<<std::endl;
30             if ((allRowValues) && (currentIndex < size)){
31                 std::cout << "ARV " <<std::endl;
32                 std::cout << allRowValues[currentIndex] << std::endl;
33                 this->matrixValues[i]= allRowValues[currentIndex];
34                 std::cout << "MAT " << allRowValues[currentIndex++] << std::endl;
35             }else{
36                 std::cout << "Else\n";
37             }
38         }
39         int index=0;
40         for (int j = 0; j < rows; j++){
41             for (int i = 0; i < columns; i++){
42                 std::cout << this->matrixValues[index++];
43             }
44             std::cout<<std::endl;
45         }
46     };
47 
48     Matrix::Matrix(double* rowValues){
49         int sizeRows = sizeof(rowValues)/sizeof(double);
50         //TODO: throw error for all rows must be the same length
51         this->rows = sizeRows;
52         int sizeColumns = sizeof(rowValues[0])/sizeof(double);
53         this->columns = sizeColumns;
54         this->matrixValues = rowValues;
55     };
56 
57     double Matrix::width(){
58         std::cout << "Width\n";
59         return this->columns;
60     };
61 
62     double Matrix::height(){
63         std::cout << "Height\n";
64         return this->rows;
65     };
66 
67     std::string Matrix::toString(){
68         int numberOfValues = 0;
69         std::cout<<matrixValues[numberOfValues];
70         std::string build_output;
71         std::cout<<matrixValues;
72         for (int i = 0; i < rows; i++){
73             build_output = "[";
74             std::cout << "\n";
75             for (int j = 0; j < columns; j++){
76                 std::cout << "VALUE: " <<matrixValues[numberOfValues];
77                 build_output = matrixValues[numberOfValues];
78                 numberOfValues++;
79             }
80             build_output = " ]";
81         }
82         return build_output;
83     }
84 
85     int main (){
86         double values[6] = {1, 2, 3, 4, 5, 6};
87         std::cout <<"Values: \n";
88         Matrix a = Matrix(2, 3, values);
89         std::cout << a.width() << std::endl;
90         std::cout << a.height() << std::endl;
91         std::cout << a.toString();
92         return 1;
93 }

Answer 1

double allRowValues[]声明一个指针，而不是一个数组。表达式 sizeof(allRowValues)/sizeof(double)然后计算指针的大小与 double 的大小之间的比率.如果 double 更大，结果显然为零。

出于某种原因，同样的错误也发生在另一个构造函数中(sizeof(rowValues)/sizeof(double))，但这次参数显然是一个指针。然后是 sizeof(rowValues[0])/sizeof(double)这是 double 组的大小一元素(即 double )与 double 的大小(显然是一)之间的比率。

似乎人们相信 sizeof运算符可以神奇地知道给定指向数组第一个元素的指针的大小。它不能。或者数组和指针之间可能存在混淆。他们是 not the same .

大多数时候，数组(即 T[N] 类型的对象，如 double[100] )只是衰减到指向其第一个元素的指针(即 T*，如 double* )，在此过程中丢失大小信息。这就是为什么如果你打算“传递一个数组”，你永远不能只传递一个指针。您需要以某种方式传递尺寸信息。

您可以将大小作为额外参数显式传递，或传递另一个标记缓冲区结尾的指针(迭代器样式)。您还可以传递对数组的引用(这可以防止衰减为指针，从而保留大小信息)并使用模板来获取大小信息。

template <std::size_t N, std::size_t M>
void pass_a_2d_array_by_reference(double(&the_array)[N][M]) { // N and M are the sizes
    // do stuff
}

---

既然您了解了这些问题，那么如果您使用现成的解决方案，您就可以完全避免这些问题:

• std::vector<std::vector<double>> :如果您不需要连续存储，这是一个非常好的解决方案。如果您想要锯齿状阵列，这也是您的最佳选择。
• boost::multiarray<double, 2> :另一个非常好的解决方案，它同样适用于更多维度的数组；
• 还有许多其他现有解决方案可满足各种需求。环顾四周。