如何向构造函数传递数组值？求2x2矩阵的构造函数写法

Hey there! Let's break this down step by step so it makes total sense, especially focusing on regular types (like int) first, then touching on generics to clear up your confusion.

Option 1: Use Nested std::initializer_list (C++11+) #

This is the most straightforward approach that directly matches the {{1,2}, {5,6}} syntax you want. std::initializer_list is a C++11 feature designed to handle list-based initialization, and you can nest them to represent rows and columns.

Here's a complete example for an integer 2x2 matrix:

#include <initializer_list>
#include <iostream>

class Matrix {
private:
    int data[2][2]; // Store the 2x2 matrix values
public:
    // Constructor that accepts nested initializer lists
    Matrix(std::initializer_list<std::initializer_list<int>> init) {
        int row_idx = 0;
        // Iterate over each row in the outer list
        for (const auto& row : init) {
            int col_idx = 0;
            // Iterate over each value in the row
            for (int val : row) {
                // Guard against out-of-bounds entries (optional but safe)
                if (row_idx < 2 && col_idx < 2) {
                    data[row_idx][col_idx] = val;
                    col_idx++;
                }
            }
            row_idx++;
        }
    }

    // Helper method to print the matrix (for testing)
    void print() const {
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                std::cout << data[i][j] << " ";
            }
            std::cout << "\n";
        }
    }
};

// Usage example
int main() {
    Matrix test = {{1, 2}, {5, 6}};
    test.print(); // Outputs: 1 2 \n 5 6
    return 0;
}

How This Works: #

• The constructor parameter std::initializer_list<std::initializer_list<int>> tells the compiler to expect a list of lists of integers—exactly what {{1,2}, {5,6}} is.
• We loop through each "row" list, then each value in the row, and copy them into our internal data array.
• The bounds check ensures we don't accidentally write beyond our 2x2 matrix if someone passes extra values.

Option 2: Use a Reference to a 2x2 Array #

If you want strict type checking (to ensure the input is exactly a 2x2 array), you can define the constructor to take a reference to a fixed-size 2x2 array:

class Matrix {
private:
    int data[2][2];
public:
    // Constructor takes a reference to a 2x2 int array
    Matrix(int (&arr)[2][2]) {
        // Copy values from the input array to our internal data
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                data[i][j] = arr[i][j];
            }
        }
    }
};

You can still initialize it with Matrix test = {{1,2}, {5,6}};—the compiler will automatically convert the initializer list into a 2x2 array and pass it to the constructor. The benefit here is that the compiler will throw an error if someone tries to pass a non-2x2 array, which adds safety.

Extending to Generic Types (Clearing Up Your Confusion) #

If you want a matrix that works with any regular type (like double, float, etc.), you can turn the Matrix class into a template. The logic is almost identical—you just replace int with a template parameter:

#include <initializer_list>
#include <iostream>

template <typename T>
class Matrix {
private:
    T data[2][2];
public:
    Matrix(std::initializer_list<std::initializer_list<T>> init) {
        int row_idx = 0;
        for (const auto& row : init) {
            int col_idx = 0;
            for (const T& val : row) {
                if (row_idx < 2 && col_idx < 2) {
                    data[row_idx][col_idx] = val;
                    col_idx++;
                }
            }
            row_idx++;
        }
    }

    void print() const {
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                std::cout << data[i][j] << " ";
            }
            std::cout << "\n";
        }
    }
};

// Usage examples
int main() {
    Matrix<int> int_matrix = {{1, 2}, {5, 6}};
    Matrix<double> double_matrix = {{1.1, 2.2}, {3.3, 4.4}};
    
    int_matrix.print();
    double_matrix.print();
    return 0;
}

This works because the template parameter T acts as a placeholder for any type you want to use. The initializer list constructor adapts to whatever type T is, so you can use the same {{...}, {...}} syntax for integers, doubles, or any other regular type.

内容的提问来源于stack exchange，提问作者Cool Guy