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

Matrix slice有几个问题：

无法定义具有两种可能类型的变量，并且在同一范围内都具有活动性。
int的返回类型毫无意义。矩阵被切成碎片，但接着是什么？它无法通过它回复给调用者。

这可以通过union修复，但是可以！对此的记账将是一场蓝精灵的噩梦。不要这样做！

接下来要始终使用vector vector，但我不喜欢这个想法有几个原因，我将在下面介绍。

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

它保留了使用1维容器支持1维矩阵的能力。如果您有一列的多行，则所有行数据都保持连续且缓存友好。
它往往要快得多。一个vector的数据在内存中是连续的，并且获得了缓存友好性的回报。 vector vector基本上是指向数据数组的指针列表，通过内存中的指针追逐的odyssey发送可怜的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;
}

并不是说这完全忽略了使切片成为Matrix方法的非常合理的选择。虽然它有意义，但它不需要是一种方法，股票推荐是喜欢自由功能。一个很好的改进是使该函数成为一个模板，以便除了Matrix之外它还可以处理各种Matrix<int>。

最后，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

在您的代码中

Dim a_b_c_d As String, abcd As String

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

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

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

2 个答案: