Question

目前我有一个2D矢量，包含600个值“块”，每个块中有2个值。我想要做的是，创建一个新的向量矢量来对块进行分段，因此我将存储10或任何给定数量的块，而不是存储的值为2。

这是一个例子，使用一个小矢量矢量：

std::vector<std::vector<double> > values = { {1, 2}, {2, 4}, {5, 8}, {4, 5} };

因此可以将其分段为2，因此，哪个块将包含4个块。 E.g。

std::vector<std::vector<double> > values2 = { {1, 2, 2, 4}, {5, 8, 4, 5} };

向量矢量中现在有两个块，每个块现在包含4个值。

但这怎么可能呢？我只是用来分割1D向量，所以对于这个任务，使用std::copy和std::back_inserter是否有效解决这个问题？在实际问题中，我有600个块，每个块包含2个值。

谢谢

Answer 1

以下是您的简化示例的代码。我希望它能帮助或至少显示正确的方向。

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

int main() 
{
    typedef std::vector<std::vector<double>>::size_type size_type;
    const size_type N = 4;


    std::vector<std::vector<double>> v1 = { {1, 2}, {2, 4}, {5, 8}, {4, 5}, { 7, 8 } };

    for ( const auto &v : v1 )
    {
        for ( double x : v ) std::cout << x << ' ';
        std::cout << std::endl;
    }

    std::cout << std::endl;

    size_type n = 
        std::accumulate( v1.begin(), v1.end(), size_type( 0 ),
                         [] ( size_type acc, const std::vector<double> &v )
                         {
                            return ( acc + v.size() );
                         } );

    std::vector<std::vector<double>> v2( ( n + N - 1 ) / N );

    std::cout << "v2.size() = " << v2.size() << std::endl;

    auto it = v1.begin();

    for ( std::vector<double> &v : v2 )
    {
        for ( size_type i = 0; i < N / 2 && it != v1.end(); ++it, ++i )
        {
            v.insert( v.end(), ( *it ).begin(), ( *it ).end() );
        }
    }

    for ( const auto &v : v2 )
    {
        for ( double x : v ) std::cout << x << ' ';
        std::cout << std::endl;
    }

    std::cout << std::endl;

    return 0;
}

输出

1 2 
2 4 
5 8 
4 5 
7 8 

v2.size() = 3
1 2 2 4 
5 8 4 5 
7 8

如果您的编译器不支持C ++ 11，则此范围基于

    auto it = v1.begin();

    for ( std::vector<double> &v : v2 )
    {
        for ( size_type i = 0; i < N / 2 && it != v1.end(); ++it, ++i )
        {
            v.insert( v.end(), ( *it ).begin(), ( *it ).end() );
        }
    }

可以替代

    typedef std::vector<std::vector<double>>::iterator iterator;

    iterator it1 = v1.begin();

    for ( iterator it2 = v2.begin(); it2 != v2.end(); ++it2 )
    {
        for ( size_type i = 0; i < N / 2 && it1 != v1.end(); ++it1, ++i )
        {
            ( *it2 ).insert( ( *it2 ).end(), ( *it1 ).begin(), ( *it1 ).end() );
        }
    }

顺便说一下，最好使用基于范围而不是标准算法。：）

例如

size_type n = 0;
for ( const auto &v : v1 ) n += v.size();

C ++中2D向量的分割

1 个答案: