C++ 如何在pre c++；11语法？

我已经阅读了大量关于这个主题的问题和答案，但没有一个能帮我解决这个问题

我有一个向量向量，用C++ 11代码初始化，如：：/p>

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

---

如何在尽可能少的行中将其转换为c++11之前的语法？

基本代码如下所示。更快的替代方法可以避免重复调用

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;

std:：向量a；
a、 向后推（std:：vector（））；
a、 后退（）。向后推（1）；
a、 后退（）。向后推（1）；
a、 后退（）。向后推（1）；
a、 向后推（std:：vector（））；
a、 后退（）。向后推（1）；
a、 后退（）。向后推（2）；
a、 向后推（std:：vector（））；
a、 后退（）。向后推（2）；
a、 后退（）。向后推（1）；
a、 向后推（std:：vector（））；
a、 后退（）。向后推（3）；
返回a；

从数组分配或构造是一个简单的选项：

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]);

inttemp[]={1,1,1,1,2,2,1,3}；
std：：载体a（4）；
a[0]。分配（&temp[0]，&temp[3]）；
a[1]。分配（&temp[3]，&temp[5]）；
a[2]。分配（&temp[5]，&temp[7]）；
a[3]。分配（&temp[7]，&temp[8]）；
在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

名称空间我的{
使用std：：vector；
向量>
foo（）
{
int const a0[]={1,1,1}；
int const a1[]={1,2}；
int const a2[]={2,1}；
int const a3[]={3}；
typedef cppx:：数组_range R；
R常数范围[]={a0，a1，a2，a3}；
返回make_vec（范围）；
}
}//名称空间我的

相关支持：

#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

#包括
#包括//ptrdiff\t
#包括
命名空间cppx{
使用std：：vector；
typedef ptrdiff\t大小；
typedef大小索引；
模板<类别项目，大小n>
大小n_项（项（&）[n]）{return n；}
模板<类类型>
结构非常量{typedef Type T；}；
模板<类类型>
结构非常量{typedef Type T；}；
模板<类项目>
结构数组\u范围
{
项目*施工图开始；
项目*施工图结束；
模板
数组\u范围（项目（&a）[n]）
：p_begin（a）
，p_端（a+n）
{}
};
模板<类别项目，大小n>
矢量
制造成本（项目（&a）[n]）
{
返回向量（a，a+n）；
}
模板<类别项目，大小n>
vector>
生成向量（数组范围常数（&a）[n]）
{
typedef typename非常量：：T Nc_项；
矢量>结果；
对于（指数i=0；i(
a[i].p_开始，a[i].p_结束
) );
}
返回结果；
}
}//名称空间cppx

免责声明：（1）我刚刚输入了此答案的支持代码，修复了我偶然发现的直接
const
-ness问题。因此，可能存在可重用性问题，但它显示了总体思路（并且是有效的）。（2） 我只使用MinGW g++（tdm64-1）5.1.0编译了它。
不幸的是，我猜您需要创建一个
向量
，因此另一个
向量
，一次填充后面的一个
推回
，然后将它推回到前者中，等等…把你的编译器转换成C++11兼容的：）当然是开玩笑了…这是非常脆弱的代码。维护人员很容易在不经意间把事情弄糟。