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

Posted 2023-02-21

【中文标题】如何在 C++ 中打印矢量 <vector<int>>？ [复制]

【英文标题】：How to print vector <vector<int>> in c++? [duplicate]

【发布时间】：2020-09-05 13:35:32

【问题描述】：

我正在尝试动态分配和打印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;

【问题讨论】：

您需要两个循环来执行此操作。 std::vector<int> 没有定义 std::ostream 的输出运算符。因此，只需将另一个 for 循环嵌套到您已有的循环中即可。

能否请您发布代码 sn-p 我对 C++ 和 STL 非常陌生

我相信它足够简单，如果你自己弄清楚，你会有更好的学习效果。您拥有的代码几乎就在那里。所以没有。

避免对类和变量使用相同的名称。

将 vector <int> A(s) 更改为 vector <int> A 否则说对于 n = 5 它将创建一个长度为 5 的向量，用 0, 0, 0, 0, 0 初始化并再次推送 0, 1, 2, 3, 4 最终将导致 0, 0, 0, 0, 0, 0, 1, 2, 3, 4

【参考方案1】：

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

为此，您需要 2 个循环。

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

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

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 

【讨论】：

感谢您详细说明我的代码中的更多问题 :)

永远！如果有帮助，请为答案投票。

【参考方案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;
    

谢谢。

【讨论】：

这可能会让 OP 感到困惑，而不是帮助。他们已经正确掌握了迭代器，现在您无需进一步解释就向他们介绍一个全新的概念。

同意的迭代器现在很好，第一种方法有点令人困惑，但是他已经更新了两种方式的解决方案，所以我认为他应该得到 +1 :)

【参考方案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;
    

【讨论】：

完美，这就是我想要的！我现在明白了它的概念，基本上我们必须根据我们有多少嵌套来初始化多个迭代器谢谢:)

【参考方案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

【参考方案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，这将需要创建可调用对象，如果可调用对象可以重复使用或与其他对象交换，则可以首选此方法，从而提供一定的灵活性。

【讨论】：

for_each 不适合使用

@lajoh90686 原谅？

for_each 并不是为了像这样立即调用而设计的。你有基于范围的 for 循环，甚至是正常的 for 循环。这是对简单 for 循环的过度复杂的误用或过度设计的解决方案

@lajoh90686 我们不知道 OP 实际有什么目的，他的例子是一个最小的娱乐。 for_each 和类似的用于模板代码或通用代码中的惯用用法，在通用 lambda 中使用是合适的，因为它是一个模板。 OP 实际所做的和选择的取决于它们的实际应用程序。使用 C++20，我们也有这些迭代函数的并行模拟，但在这里不相关。请注意，某些部分兼容但在某些行业中流行的编译器不支持基于范围的 for，但支持那些其他功能。

// pushes a vector on vector A 很明显 OP 只是在学习。你很难找到答案是 std::for_each 这样的问题。在我多年的 C++ 编程中，for_each 是算法库中最没用的特性之一。尤其是当你可以只做for(auto a: std::ranges::view::reverse(as)) （或者用你的迭代器助手替换反向 - 我选择了一个 C++20 因为它是标准的）