如何使用C ++ 11以前的語法初始化向量的向量？

Question

我已經閱讀了很多有關這個確切主題的問題和答案，但是沒有一個問題可以幫助我解決這個問題。

我有一個向量，向量是使用c ++ 11代碼初始化的，如下所示：

return { {1,1,1}, {1,2}, {2,1}, {3} };

如何在盡可能少的行中將其轉換為c ++ 11之前的語法？

Answer 1

通過數組進行分配或構造是一個簡單的選擇：

int temp[] = { 1, 1, 1, 1, 2, 2, 1, 3 };
std::vector<std::vector<int>> a(4);
a[0].assign(&temp[0], &temp[3]);
a[1].assign(&temp[3], &temp[5]);
a[2].assign(&temp[5], &temp[7]);
a[3].assign(&temp[7], &temp[8]);

Answer 2

基本代碼如下所示。 更快的替代方法可以避免重復調用back() ，但這是查看其與原始文件的關系的最清晰方法。

std::vector<std::vector<int>> a;
a.push_back(std::vector<int>());
a.back().push_back(1);
a.back().push_back(1);
a.back().push_back(1);
a.push_back(std::vector<int>());
a.back().push_back(1);
a.back().push_back(2);
a.push_back(std::vector<int>());
a.back().push_back(2);
a.back().push_back(1);
a.push_back(std::vector<int>());
a.back().push_back(3);
return a;

Answer 3

在C ++ 03（或C ++ 98）中編寫可維護代碼的關鍵思想是命名事物。 一般來說，這也是一個好主意，但它可能與合理簡潔的理想相抵觸。 也就是說，它很容易變得太冗長而完全沒有痛苦。

在適當的支持下，人們可以編寫如下代碼

namespace my{
    using std::vector;

    vector< vector< int > >
        foo()
    {
        int const a0[] = {1,1,1};
        int const a1[] = {1,2};
        int const a2[] = {2,1};
        int const a3[] = {3};
        typedef cppx::Array_range<int const> R;
        R const ranges[] = {a0, a1, a2, a3};
        return make_vecvec( ranges );
    }
}  //  namespace my

相關支持：

#include <iostream>
#include <stddef.h>     // ptrdiff_t
#include <vector>

namespace cppx {
    using std::vector;
    typedef ptrdiff_t Size;
    typedef Size Index;

    template< class Item, Size n >
    Size n_items( Item (&)[n] ) { return n; }

    template< class Type >
    struct Non_const{ typedef Type T; };

    template< class Type >
    struct Non_const< Type const > { typedef Type T; };

    template< class Item >
    struct Array_range
    {
        Item* const p_begin;
        Item* const p_end;

        template< Size n >
        Array_range( Item (&a)[n] )
            : p_begin( a )
            , p_end( a + n )
        {}
    };

    template< class Item, Size n >
    vector<typename Non_const<Item>::T>
        make_vec( Item (&a)[n] )
    {
        return vector<typename Non_const<Item>::T>( a, a + n );
    }

    template< class Item, Size n >
    vector< vector< typename Non_const<Item>::T > >
        make_vecvec( Array_range<Item> const (&a)[n] )
    {
        typedef typename Non_const<Item>::T Nc_item;
        vector< vector< Nc_item > > result;
        for( Index i = 0; i < n; ++i )
        {
            result.push_back( vector< Nc_item >(
                a[i].p_begin, a[i].p_end
                ) );
        }
        return result;
    }
}  // namespace cppx

免責聲明：（1）我剛剛輸入了此答案的支持代碼，解決了我偶然發現的直接const問題。 因此，可能存在可重用性問題，但它顯示了總體思路（並且有效）。 （2）我僅使用MinGW g ++（tdm64-1）5.1.0進行了編譯。