如何在 C++ 中打印矢量 <vector<int>>？ [复制]

Question

我正在尝试动态分配和打印vector<vector<int>>，但是我不知道该怎么做我被困在这里是我的程序

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class A {
public:
    vector<int> getVector(int s) {

        vector <int> A(s);
        for (int j = 0; j < s; j++) {
            A.push_back(j);
        }
        return A;
    }
};
int main() {
    A obj;
    int n = 5;
    vector<vector<int>> A;
    
    A.push_back(obj.getVector(n));     // pushes a vector on vector A
    A.push_back(obj.getVector(n - 1));

    vector<vector<int>> ::iterator it;
    it = A.begin();
    for (it; it != A.end(); it++) {
        cout << *it;
    }


    return 0;
}

Answer 1

将矢量 视为动态二维数组。

为此，您需要 2 个循环。

另外，您需要更改一些内容：

1. vector <int> A(s); 将初始化一个大小为s 的向量，所有元素都设置为0，然后您将第一个n 元素推入A。所以，将vector <int> A(s); 更改为vector <int> A;。

2. using namespace std 不被视为一种好的做法。找出原因。

看看下面的实现：

#include<iostream>
#include<vector>
#include<string>

class A {
    
    public:
        
        std::vector<int> getVector(int s) {

            std::vector <int> A; //Change 1

            for (int j = 0; j < s; j++) {
                A.push_back(j);
            }
            return A;
        }
};

int main() {

    A obj;
    int n = 5;
    std::vector<std::vector<int>> test_vector;
    
    test_vector.push_back(obj.getVector(n));     // pushes a vector on vector A
    test_vector.push_back(obj.getVector(n - 1));

    std::vector<std::vector<int>> :: iterator test_vector_iterator;
    
    test_vector_iterator = test_vector.begin();
    
    for (test_vector_iterator; test_vector_iterator != test_vector.end(); test_vector_iterator++) {
        
        std::vector<int> :: iterator inner_vector_iterator = (*test_vector_iterator).begin();

        for(inner_vector_iterator; inner_vector_iterator != (*test_vector_iterator).end(); inner_vector_iterator++){

            std::cout << *inner_vector_iterator <<" ";
        }

        std::cout << std::endl;
    }


    return 0;
}

输出：

0 1 2 3 4 
0 1 2 3 

Answer 2

使用range循环类似

for( const auto &i : A )      // for elements in A, i is vector<int>
{
    for( const auto &j : i )  // for sub elements in A, j is int
    {
        std::cout<<j;
    }
}

或使用迭代器

for( vector<vector<int>>::iterator i = A.begin() ; i != A.end(); i++ )
{
    for( vector<int>::iterator j = i->begin(); j != i->end(); j++ )
    {
        std::cout<<*j;
    }
}

谢谢。

Answer 3

vector<vector<int>> ::iterator it;
    it = A.begin();
    for (it; it != A.end(); it++) {
        for(vector<int>::iterator it2 = it->begin(); it2 != it->end(); ++it2)
            cout << *it2;
    }

Answer 4

嵌套的std::for_each 可以解决问题

将给定的函数对象 f 应用于解引用的结果 [first, last) 范围内的每个迭代器，按顺序排列。

我们将使f 以std::vector<int> 为参数，并打印出来。

#include <iostream>
#include <vector>
#include <algorithm>


int main()
{
    std::vector<std::vector<int>> A{ {1,2}, {3, 4} };

    std::for_each(A.begin(), A.end(), [](const auto& v) {
        std::for_each(v.begin(), v.end(), [](auto const& it) {
            std::cout << it << std::endl;
        });
    });

    return 0;
}

---

输出

1
2
3
4

Answer 5

向量的向量是二维数组的模拟。序列化向量没有标准方法，嵌套循环即可。

#include<iostream>
#include<vector>
#include<string>
#include <algorithm>

using std::for_each;
using std::cout;
using std::vector;
using std::endl;

class A {
public:
    vector<int> getVector(int s) {

        vector <int> A(s);
        for (int j = 0; j < s; j++) {
            A.push_back(j);
        }
        return A;
    }
};
int main() {
    A obj;
    int n = 5;
    vector<vector<int>> A;
    
    A.push_back(obj.getVector(n));     // pushes a vector on vector A
    A.push_back(obj.getVector(n - 1));

    // classic for loop
    for (auto itV = A.begin(), itVE =  A.end(); itV != itVE; itV++)
    {
        for (auto itI = itV->begin(), itIE = itV->end(); itI != itIE; itI++) 
        {
             cout << *itI;
        }
    }
    cout << endl;
    
    // much simpler range-based loop
    for (auto& rowV : A )     // note that this a reference 
                              // - no copy of stored vector is made.
        for (auto el : rowV)
             cout << el;

    cout << endl;

    // a generic lambda to serialize vector
    auto print_vector =  [](const auto& v) {
        std::for_each(v.begin(), v.end(), [](auto const& it) {
            std::cout << it << std::endl;
        });
    };

    std::for_each(A.begin(), A.end(), print_vector );

    return 0;
}

有几种方法可以做到这一点：使用经典的 for()，它非常拗口，但允许对某些方面进行控制，基于范围的 for 循环是最短和最简洁的变体。第三种方法是使用标准库中的惯用函数，如 for_each，这将需要创建可调用对象，如果可调用对象可以重复使用或与其他对象交换，则可以首选此方法，从而提供一定的灵活性。