二维向量矩阵的加法

vector<vector<int>> AsumB(vector<vector<int>> const & matrix1,
                          vector<vector<int>> const & matrix2) {
    vector<vector<int>> matrix(matrix1);
    for (std::size_t i = 0U; i < matrix.size(); ++i)
        for (std::size_t j = 0U; j < matrix[j].size(); ++j)
            matrix[i][j] += matrix2[i][j];
    return matrix;
}

?

无法复制，并且OP报告的编译器错误看起来与代码不匹配，因此问题可能在其他地方。

然而，这里有很多错误，可能会导致各种各样的坏，应该解决。我冒昧地重新格式化了一下代码，以便更容易解释

vector<vector<int>> AsumB(int kolumny,
                          vector<vector<int>> matrix1,
                          vector<vector<int>> matrix2)

matrix1和matrix2按值传递。逻辑上没有问题，但这意味着有可能进行大量不必要的复制，除非编译器非常敏锐。

{
    vector<vector<int>> matrix(kolumny);

声明vector s的vector，外部vector大小为kolumny。没有分配内部vector，所以2D操作注定失败。

    matrix = vector<vector<int>>(matrix1.size());

创建vector的临时vector，外部vector的大小与matrix1的外部向量匹配。然后将这个临时向量赋值给刚刚创建的matrix，替换它的当前内容，然后销毁。matrix仍然没有分配内部向量，所以2D操作仍然失败。

    for (int i = 0; i < kolumny; ++i)
        for (int j = 0; i < (static_cast<signed int>(matrix1.size())); ++i)

i和j不应该是负的(如果它们是负的，会产生巨大的逻辑问题)，所以使用unsigned类型。使用正确的unsigned类型，static_cast就没有意义了。

此外，内部for循环对i递增并测试，而不是j

            matrix[i][j] = matrix1[i][j] + matrix2[i][j];

除了matrix没有j索引之外，我没有看到任何问题。当访问越界时，这将导致未定义行为。

    return matrix;
}

清理这个，使它在逻辑上是合理的:

vector<vector<int>> AsumB(const vector<vector<int>> & matrix1,
                          const vector<vector<int>> & matrix2)

我们不需要列的数量。向量已经知道所有的大小。不过需要注意的是:vector<vector<int>>允许所有内部vector s的不同大小。别这样，你应该表现得很好。

接下来，该函数现在通过常量引用接受形参。参考资料没有抄袭。对于const，编译器知道向量不会在函数内改变，可以防止错误并进行一系列优化。

{
    size_t row = matrix1.size();

size_t是一个unsigned数据类型，保证足够大，可以索引任何可表示的对象。这样就足够了，你不用担心那些烦人的负数。也消除了以后任何类型转换的需要。

    if (!(row > 0 && row == matrix2.size()))
    {
        return  vector<vector<int>>();
    }

在这里，我们确保每个人都同意所涉及的行数，如果他们不同意，则返回空vector。您还可以抛出异常。异常可能是一个更好的解决方案，但我不知道用例。

    size_t column = matrix1[0].size();
    if (!(column > 0 && column == matrix2[0].size()))
    {
        return  vector<vector<int>>();
    }

执行与上面相同的操作，但要确保列的数量是合理的。

    vector<vector<int>> matrix(row, vector<int>(column));

创建一个本地行逐列矩阵来存储结果。注意第二个参数。vector<int>(column)告诉编译器所有的row内部向量将初始化为大小为column的vector。

    for (int i = 0; i < row; ++i)
    {
        for (int j = 0; j < column; ++j)
        {

这里我们简化了循环，因为我们知道所有循环的大小。

            matrix[i][j] = matrix1[i][j] + matrix2[i][j];
        }
    }
    return matrix;

编译器有许多技巧来消除在返回时复制矩阵。如果您想了解更多，请使用您首选的网络搜索引擎查找返回值优化。}

一起:

vector<vector<int>> AsumB(const vector<vector<int>> & matrix1,
                          const vector<vector<int>> & matrix2)
{
    size_t row = matrix1.size();
    if (!(row > 0 && row == matrix2.size()))
    {
        return  vector<vector<int>>();
    }
    size_t column = matrix1[0].size();
    if (!(column > 0 && column == matrix2[0].size()))
    {
        return  vector<vector<int>>();
    }
    vector<vector<int>> matrix(row, vector<int>(column));
    for (int i = 0; i < row; ++i)
    {
        for (int j = 0; j < column; ++j)
        {
            matrix[i][j] = matrix1[i][j] + matrix2[i][j];
        }
    }
    return matrix;
}