Question

我的模型最好使用一些

v int [30] [i] [N_i];

结构是整数元组的30个向量，其中

v [0]是假人，
v [1]是普通的整数（N_0），
v [2]是int（N_1对）对 ...
v [29]将是29元组的int（其中N_29个）

not vector<vector<int>>就像“generic-vector-of-vectors-in-c”

显然，外部固定dim = 30没问题，内部固定dl由自扩展STL矢量类处理。

有没有办法让中间维度固定，但不能保持不变？

Answer 1

正如我在对你的问题的评论中写道的那样，我不确定你在寻找什么（我对“在Java中的作用”部分BTW非常感兴趣）。

但是，因为我认为看看如何使用Boost生成它会很有趣。MPL（以及Fusion ...和Array），我假设你想要一个静态定义的结构，其Ntn元素是大小为N的int数组的向量：

#define FUSION_MAX_VECTOR_SIZE 30

#include <boost/mpl/transform.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/inserter.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/size_t.hpp>

#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/include/as_vector.hpp>

#include <boost/array.hpp>

#include <vector>


namespace bf = boost::fusion;
namespace bmpl = boost::mpl;

// Type generator used for elements 2..N
// For those elements, the type of the n'th element is
// std::vector<boost::array<int, n>>
template<class SizeT>
struct VectorOfArray
{
    typedef std::vector<boost::array<int, SizeT::type::value> > type;
};

// The dummy type used for the first element
struct Dummy{};

// The container itself
template<size_t Size>
struct StrangeContainer
{

    // Define a fusion::vector (this is, more or less, equivalent to a tuple)
    // of "Size" elements, where:
    // - the type of element 0 is Dummy, 
    // - the type of element 1 is vector<int>
    // - the type of the n'th element is vector<array<int, n>>
    typedef typename bf::result_of::as_vector<
        typename bmpl::transform<
            bmpl::range_c<size_t, 2, Size>,
            VectorOfArray<bmpl::_1>,
            bmpl::back_inserter<
                bmpl::vector<Dummy, std::vector<int> >
            >
        >::type
    >::type ContentsType;

    // Helper struct to compute the return type of the "At()" member
    template<size_t I>
    struct ElemType
    {
        typedef typename VectorOfArray<bmpl::size_t<I> >::type type;
    };

    // Specialize "At()"'s return type for element 1
    template<>
    struct ElemType<static_cast<size_t>(1)>
    {
        typedef std::vector<int> type;
    };

    // Specialize "At()"'s return type for element 0
    template<>
    struct ElemType<static_cast<size_t>(0)>
    {
        typedef Dummy type;
    };

    // Get the I'th element
    template<size_t I>
    typename ElemType<I>::type& 
    At()
    {
        return bf::at_c<I>(m_Contents);
    }

    // The fusion vector holding the elements
    ContentsType m_Contents;
};

int main()
{
    StrangeContainer<30> s;
    Dummy& d = s.At<0>();
    s.At<1>().push_back(1);
    s.At<2>().push_back(boost::array<int, 2>());
    s.At<3>().push_back(boost::array<int, 3>());
    s.At<29>().push_back(boost::array<int, 29>());
    s.At<29>()[0][0] = 1234;

    return 0;
}

Answer 2

执行所需操作的最佳方法是在向量访问器周围编写包装函数。包装现有行为的最好方法是编写一个新的类，用你喜欢的矢量矢量实现。

Answer 3

我是Michael（最初的作者）现在拥有ID La-AIDA

首先，谢谢大家，Boost＆amp;融合对我来说是新的。

致Éric：一个错字：v [1]应该有N_1个条目，v [2] N_2等等。我想要类似STL的东西，而不是C数组（缺少边界检查，没有选项可以添加它）。

对Éric的新评论：我尝试了你的解决方案，它立即工作（几乎，在删除虚拟查询后）！谢谢！但是：我需要像

这样的东西

 for (i = 1;i < 30;i++) {
    cout << s.At<i>[0] << endl; 
 }

即At＆lt; ..＆gt;的索引应该是可变的（这是整点，能够运行索引，而不是分别处理30个硬编码的东西）但是gcc抱怨错误：'我'不能出现在常量表达式

中

关于“在Java中”： AfaIk，Java中的双暗矩阵并不是一些 int v [10] [10]; 固定尺寸，但有类似的东西 int [] [] v; 你第一次拥有

的地方

v = new int[10][];

（或类似语法）然后，这就是重点：

v[0] = new int[1];
...
v[9] = new a[10];

制作三角形矩阵，当然还有任何你喜欢的形式。事实上，一个普通的10×10矩阵也需要1加10个新的。

关于结构本身：

是等效的数据结构

vector<int> v1;
vector<pair<int,int>> v2;
vector<int,int,int> v3;
...
vector<int[29]> v29;

然而，我们必须分别处理30个部分中的每个部分。

我希望能说v[5][3][123] = 99; 将第123个5元组中的第3个组件设置为99，而不定义

vector<int> v[30][30];

这可以做到这一点，但浪费了巨大的空间，因为永远不会使用v[1][2..30][0..\infty] or more generally v[i][i+1..30][*]。

所以，在我的问题中，我有一个int的列表，另一对三元组，...，30个元组的int，它们都应该是可排序的等等，在一个结构中，不浪费空间

C ++与Java一样？：向量向量，变量长度为int

3 个答案:

C ++与Java一样？：向量向量，*变量*长度为int

3 个答案:

C ++与Java一样？：向量向量，变量长度为int