如何将向量的向量从类传递到函数而不进行复制？

Question

I wrote this program where I need to transfer a vector<vector<int>> from a class to a function to change every 0 in the vector to a 1 . This function works, but somewhere a copy of vector is created and the elements are only changed to 0 in the copy, not in the original vector. How can I fix this problem?

class Matrix {
    friend istream& operator >> (istream &in, IntArr& a) {...}
    friend ostream& operator << (ostream& out, Matrix& a) {...}
  private:
    vector < vector <int> > v;
    int rows, cols;
  public:
    Matrix(int rows, int cols) {
        this->rows = rows;
        this->cols = cols;
        v.resize(rows, vector<int>(cols));
    }
    // ...
    vector < vector <int> > GetPointer() {
        return v;
    }
    int GetRows() {
        return rows;
    }
    int GetCols() {
        return cols;
    }
};

void IndividualTask(int rows, int cols, vector < vector <int> > v) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (v[i][j] == 0) {
                v[i][j] = 1;
            }
        }
    }
}

int main() {
    Matrix arr1(2, 2);
    cin >> arr1;
    IndividualTask(arr1.GetRows(), arr1.GetCols(), arr1.GetPointer());
    cout << arr1;
    return 0;
}

Answer 1

There are a couple of related problems you absolutely need to solve first. GetPointer returns a copy, and IndividualTask takes a copy. You'll want both of these to work by adding & to the type to make them references

First, have GetPointer return a reference.

//        right here---+
//                     |
//                     v
vector < vector <int> >& GetPointer() {
    return v;
}

Second, have IndividualTask take a reference

//                                         and again here------+
//                                                             |
//                                                             v 
void IndividualTask(int rows, int cols, vector < vector <int> >& v) {
   // ...
}

---

There is a separate problem here, with the rows and cols . A std::vector already knows its size, this isn't C, you don't need to pass around array sizes like this.

You could rewrite GetRows and GetCols (which should be const anyway) to delegate to the vector's size, and not have the Matrix store rows and cols data members

int GetRows() const {
    return v.size();
}
int GetCols() const {
    // guard against the empty vector case
    if (v.empty()) { return 0; }
    // only correct if all rows have the same number of columns
    return return v[0].size();
}

This is more than just convenience, it's correct. If someone were to change the size of your v by doing m.GetPointer().resize(N); your current GetRows and GetCols would be wrong!

Your function could also use these qualities of the vector,

void IndividualTask(vector < vector <int> >& v) {
    for (std::size_t i = 0; i < v.size(); i++) {
        for (std::size_t j = 0; j < v[i].size(); j++) {
            if (v[i][j] == 0) {
                v[i][j] = 1;
            }
        }
    }
}

If you are using C++11 or alter, you can use a ranged for loop more easily

void IndividualTask(vector < vector <int> >& v) {
    for (auto& row : v) {
        for (auto& e : row) {
            if (e == 0) {
                e = 1;
            }
        }
    }
}