C++

Question

我决定在 C++ 上进行二维动态编码，我决定 table 和我的程序 return % 中关于右下字段的方法数的任务。为什么？程序：

#include <iostream>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    int arr[n][m];

    for (int i = 0; i < n; i++) 
        arr[i][0] = 1;

    for (int i = 0; i < m; i++)
        arr[0][i] = 1;

    for (int i = 1; i < n; i++) {
        for (int j = 1; j < m; j++)
            arr[i][j] = arr[i-1][j] + arr[i][j-1];
    }

    cout << arr[n-1][m-1];
}

我要回答要求： 1 10 回复： 1

Answer 1

您的程序对于 n = 1 和 m = 1 以外的任何其他大小都有未定义的行为，因为您将 non-standard VLA（可变长度数组）arr 的位置留在了外面arr[0][0] 未初始化，稍后从这些位置读取。如果你想继续使用这些non-standardVLA:s，你需要在构造它们之后对它们进行初始化。示例：

#include <cstring> // std::memset

    // ...
    int arr[n][m];
    std::memset(arr, 0, sizeof arr); // zero out the memory
    // ...

另一种既能使其初始化又符合标准 C++ 的方法是使用 std::vectors 代替：

#include <vector>

    // ...
    std::vector<std::vector<int>> arr(n, std::vector<int>(m));
    // ...

稍微麻烦一点的方法是将数据存储在 class 中的一维 vector 中，并提供访问数据的方法 就好像 它存储在二维矩阵中。 class 让您存储任意数量的维度可能如下所示：

#include <utility>
#include <vector>

template <class T, size_t Dim> // number of dimensions as a template parameter
class matrix {
public:
    template <class... Args>
    matrix(size_t s, Args&&... sizes)  // sizes of all dimensions
        : m_data(s * (... * sizes)),   // allocate the total amount of data
          m_sizes{s, static_cast<size_t>(sizes)...}, // store sizes
          m_muls{static_cast<size_t>(sizes)..., 1}   // and multipliers
    {
        static_assert(sizeof...(Args) + 1 == Dim);
        for (size_t i = Dim - 1; i--;)
            m_muls[i] *= m_muls[i + 1]; // calculate dimensional multipliers
    }

    template <size_t D> size_t size() const { return m_sizes[D]; }
    size_t size(size_t D) const { return m_sizes[D]; }

    // access the data using (y,z) instead of [y][x]
    template <class... Args>
    T& operator()(Args&&... indices) {
        static_assert(sizeof...(Args) == Dim);
        return op_impl(std::make_index_sequence<Dim>{}, indices...);
    }

private:
    template <std::size_t... I, class... Args>
    T& op_impl(std::index_sequence<I...>, Args&&... indices) {
        return m_data[(... + (indices * m_muls[I]))];
    }

    std::vector<T> m_data;
    size_t m_sizes[Dim];
    size_t m_muls[Dim];
};

有了这样的包装器，您只需稍微更改一下实现即可：

#include <iostream>

int main() {
    int n, m;
    if(!(std::cin >> n >> m && n > 0 && m > 0)) return 1;

    matrix<int, 2> arr(n, m);

    for (int i = 0; i < arr.size<0>(); i++)
        arr(i, 0) = 1;

    for (int i = 0; i < arr.size<1>(); i++)
        arr(0, i) = 1;

    for (int i = 1; i < n; i++) {
        for (int j = 1; j < m; j++) 
            arr(i, j) = arr(i - 1, j) + arr(i, j - 1);
    }

    std::cout << arr(n - 1, m - 1) << '\n';
}

C++ - 响应是 int%

C++ - response is int%