不能使用 push_back 将整数插入 1D/2D 向量

Question

我正在尝试编写一个函数来从给定矩阵中提取切片，其中输入是 1D，切片可以是 1D 或 2D。 我正在尝试为此目的使用push_back 函数，但由于某些原因push_back 不起作用。 我在OutPut.push_back(DumyValue); 行中收到错误消息

谁能帮助我为什么会收到此错误？ 另外，如果您能告诉我如何解决这个问题，我们将不胜感激。 另外，如果第一部分变得清晰，谁能告诉我应该如何使用 push_back 在特定位置插入一个整数，以便我可以使用它来提取 2D 切片？

如果删除OutPut.push_back(DumyValue); 行，代码应该可以工作。

#include<iostream>
#include<vector>
using namespace std;



int MatrixSlice(vector<vector<int>> Input, int Row1, int Row2, int Col1, int Col2) {
 //define the slice size, if it is iD or 2D

 if (abs(Row1-Row2)>1 && abs(Col1-Col2)>1){
      vector<vector<int>> OutPut; 
  }else{
      vector<int> OutPut; 
  }

   int i2;
   int j2;

   for (int i = Row1; i <= Row2; i++) {
        i2=0;
       for (int j = Col1; j <= Col2; j++) {
           int DumyValue=Input[i][j];
           OutPut.push_back(DumyValue);
           i2++;
           //cout << Input[i][j] << endl;
       }
       j2++; 
   }


   return 0;
}

int main() {
  //Define a matrix for test:
   vector<vector<int>> Matrix2(4, vector<int>(5, 1));
   int R = 4;
   int C = 4;
   vector<vector<int>> MatrixInput(R, vector<int>(C, 1));;
   for (int i = 0; i < MatrixInput.size(); i++) {
       for (int j = 0; j < MatrixInput[0].size(); j++) {
           int temp;
            temp = i^2+j^2;
           MatrixInput[i][j] = temp;
       }
   }


   MatrixSlice(MatrixInput, 0, 3, 1, 1);
printf("\n");


   return 0;
}

Answer 1

矩阵切片有几个问题：

1. 不可能用两种可能的类型定义一个变量，并且在同一范围内都处于活动状态。
2. int 的返回类型毫无意义。矩阵被切分了，然后呢？不能将其交还给调用者以对其进行任何操作。

这可以通过union 来解决，但是哎呀！对此的簿记将是蓝精灵的噩梦。不要这样做！

接下来是始终使用vectors 中的vector，但我不喜欢这个想法，原因我将在下面讨论。

相反，我在单个 vector 周围放置一个简单的包装对象。这样做有两个原因：

1. 它保留了使用一维容器支持一维矩阵的能力。如果一列有很多行，则所有行数据都保持连续且便于缓存。
2. 它往往要快得多。一个vector 的数据在内存中是连续的，并获得缓存友好的回报。 vector 的 vectors 基本上是一个指向数据数组的指针列表，将可怜的 CPU 发送到指针追逐内存以查找列的奥德赛中。如果列很短，这真的会影响性能。

我们开始吧：

template<class TYPE>
class Matrix
{
private:
    size_t mNrRows; // note size_t. This is unsigned because there is no reason 
                    // for a matrix with a negative size. size_t is also guaranteed 
                    // to fit anything you can throw at it.
    size_t mNrColumns;
    std::vector<TYPE> mVec;
public:
    // make a default-initialized matrix
    Matrix(size_t nrRows, size_t nrColumns) :
            mNrRows(nrRows), mNrColumns(nrColumns), mVec(mNrRows * mNrColumns)
    {

    }
    // make a def-initialized matrix
    Matrix(size_t nrRows, size_t nrColumns, TYPE def) :
            mNrRows(nrRows), mNrColumns(nrColumns), mVec(mNrRows * mNrColumns,
                                                        def)
    {

    }

    // gimme a value and allow it to be changed
    TYPE & operator()(size_t row, size_t column)
    {
        // could check for out of bounds and throw an exception here
        return mVec[row * mNrColumns + column];
    }
    //gimme a value and do not allow it to be changed
    TYPE operator()(size_t row, size_t column) const
    {
        return mVec[row * mNrColumns + column];
    }
    // gimme the number of rows
    size_t getRows() const
    {
        return mNrRows;
    }
    // gimmie the number of columns.
    size_t getColumns() const
    {
        return mNrColumns;
    }

    // printing convenience
    friend std::ostream & operator<<(std::ostream & out, const Matrix & mat)
    {
        int count = 0;
        for (TYPE val: mat.mVec)
        {
            out << val;
            if (++count == mat.mNrColumns)
            {
                out << '\n';
                count = 0;
            }
            else
            {
                out << ' ';
            }
        }
        return out;
    }
};

vector 成员处理所有繁重的工作，因此the Rule of Zero 建议将复制和移动构造函数、赋值运算符和析构函数留给编译器处理。

这对MatrixSlice 有什么影响？好吧，首先它现在收到并返回Matrix 而不是vector<vector> 和int。内部使用Matrix，关于 1D 或 2D 的混淆完全消失了，从而产生了更简单的功能。

Matrix<int> MatrixSlice(const Matrix<int> & Input,
                        int Row1,
                        int Row2,
                        int Col1,
                        int Col2)
{
    Matrix<int> OutPut(Row2-Row1 + 1,
                       Col2-Col1 + 1); // but what if Row1 > Row2?

    int i2;
    int j2= 0; // definitely need to initialize this sucker.

    for (int i = Row1; i <= Row2; i++) // logical problem here: What if Row2 >= input.getRows()?
    {
        i2 = 0;
        for (int j = Col1; j <= Col2; j++) // similar problem here
        {
            int DumyValue = Input(i, j);
            OutPut(j2, i2) = DumyValue;
            i2++;
        }
        j2++;
    }

    return OutPut;
}

并不是说这完全忽略了使 slice 成为Matrix 方法的非常合乎逻辑的选择。虽然它是有道理的，但它不需要是一种方法，股票推荐是更喜欢一个免费的功能。一个很好的改进是使函数成为一个模板，以便它可以处理除了Matrix<int>之外的各种Matrix。

最后，main 会发生什么？

int main()
{
    //Define a matrix for test:
    Matrix<int> Matrix2(4, 5, 1); // initialize matrix to all 1s
    int R = 4;
    int C = 4;
    Matrix<int> MatrixInput(R, C); // default initialize the matrix
    for (int i = 0; i < MatrixInput.getRows(); i++)
    {
        for (int j = 0; j < MatrixInput.getColumns(); j++)
        {
            int temp;
            temp = i ^ 2 + j ^ 2;
            // WARNING: ^ is XOR, not exponent. Maybe OP wants i XOR 2, but not
            // likely. But if XOR is the desired operation, there is a lurking
            // order of operation bug that needs to be addressed
            MatrixInput(i, j) = temp;
        }
    }

    std::cout << MatrixInput << '\n';
    std::cout << MatrixSlice(MatrixInput, 0, 3, 1, 1);

    return 0;
}

Answer 2

在你的代码中

if (abs(Row1-Row2)>1 && abs(Col1-Col2)>1){
      vector<vector<int> > OutPut; 
      // OutPut dies here
  }else{
      vector<int> OutPut;
      // OutPut dies here 
  }
  // here is no OutPut

OutPut 只存在于 IF 语句的末尾。

您可以在没有 if 语句的情况下使用它，或者将所有使用它的代码添加到 if 语句中。