C++ 展平n维向量

我制定了一个可以递归使用的算法，该算法以非递归方式工作，但是，我无法以递归形式对其进行测试，因为我无法从模板中创建n-1维变量。
为了获得帮助，我写下了变量名及其含义：

• v

  ：n维向量

• dims

  ：n每个维度的长向量（例如：如果它是一个看起来像

  intx[3][6][4]

  的数组，那么

  dims

  看起来像：{3,6,4}）

• p

  ：尺寸的乘积，用于获得平面向量的大小（例如：3*6*4）

• ret

  ：返回的平坦向量

• sub_dims

  ：与

  dims

  execpt相同，没有第一个维度（例如：{6,4}）

• sub\u p

  ：与

  p

  相同，但没有第一个因素（例如：6*4）

• sub_ret

  ：n-1维向量的返回平面向量

守则：

template <typename T>
vector<int> dim_flat(vector<T> v, vector<int> dims)
{
    // creating variables and vectors
    int n = dims.size();
    int p = dims[0];
    for (int i = 1; i < n; i++)
    {
        p *= dims[i];
    }
    int sub_p = p / dims[0];
    vector<int> sub_dims;
    sub_dims.assign(dims.begin() + 1, dims.end());
    vector<int> ret(p);

    // algorithm
    if (n > 1)
    {
        for (int i = 0; i < dims[0]; i++)
        {
            vector<int> sub_ret = dim_flat(v[i], sub_dims);

            for (int j = 0; j < sub_p; j++)
            {
                ret[i * sub_p + j] = sub_ret[j];
            }
        }
    }
    else
    {
        // case for the input is 1D 
        // not yet written
    }

    return ret;
}

排队

vector<int> sub_ret = dim_flat(v[i], sub_dims);

---

简短回答：添加函数

std::vector<int> dim_flat (int v, std::vector<int> const &)
 { return {v}; }

附言：你为什么不简单地写如下

std::vector<int> dim_flat (std::vector<int> const & v)
 { return v; }

template <typename T>
std::vector<int> dim_flat(std::vector<std::vector<T>> const & v)
 {
   std::vector<int>  ret;

   for ( auto const & e : v )
    {
      auto s = dim_flat(e);

      ret.reserve( ret.size() + s.size() );
      ret.insert( ret.end(), s.cbegin(), s.cend() );
    }

   return ret;
 }

std:：vector dim_flat（std:：vector const&v）
{返回v；}
模板
标准：：矢量尺寸平面（标准：：矢量常数和v）
{
std：：载体ret；
用于（自动施工和设备：v）
{
自动s=调平（e）；
回收储备（回收大小（）+s大小（））；
ret.insert（ret.end（），s.cbegin（），s.cend（））；
}
返回ret；
}

谢谢！只需进行最小的调整（而不是

intv

我必须使用

tv

），它就可以工作了。由于某种原因，用于返回的C++11格式不起作用，我得到了

语法错误

，但C++98格式起作用。还感谢您对const参考的建议。尽管我知道它，而且真的想用它，但我还是忘了放在那里。

T x = v[i];
vector<int> sub_ret = dim_flat(x, sub_dims);

//// for integer only
// case input is 0-dimensional (simply a variable)
template <typename T>
vector<int> dim_flat (const T &v, const vector<int> &dims)
{
    return vector<int>(1, v);
}

// case input is n-dimensional
template <typename T>
vector<int> dim_flat(const vector<T> &v, const vector<int> &dims)
{
    // creating variables and vectors
    int n = dims.size();
    int p = dims[0];
    for (int i = 1; i < n; i++)
    {
        p *= dims[i];
    }
    int sub_p = p / dims[0];
    vector<int> sub_dims;
    sub_dims.assign(dims.begin() + 1, dims.end());
    vector<int> ret(p);

    // algorithm
    if (n > 1) // case n-dimensional
    {
        for (int i = 0; i < dims[0]; i++)
        {
            vector<int> sub_ret = dim_flat(v[i], sub_dims);
            for (int j = 0; j < sub_p; j++)
            {
                ret[i * sub_p + j] = sub_ret[j];
            }
        }
    }
    else // case 1-dimensional
    {
        for (int i = 0; i < p; i++)
        {
            vector<int> sub_ret = dim_flat(v[i], sub_dims);
            ret[i] = sub_ret[0];
        }
    }
    return ret;
}

std::vector<int> dim_flat (int v, std::vector<int> const &)
 { return {v}; }

std::vector<int> dim_flat (int v, std::vector<int> const &)
 { return std::vector<int>(1, v); }

template <typename T>
std::vector<int> dim_flat(std::vector<T> const   &  v,
                          std::vector<int> const &  dims)

std::vector<int> dim_flat (std::vector<int> const & v)
 { return v; }

template <typename T>
std::vector<int> dim_flat(std::vector<std::vector<T>> const & v)
 {
   std::vector<int>  ret;

   for ( auto const & e : v )
    {
      auto s = dim_flat(e);

      ret.reserve( ret.size() + s.size() );
      ret.insert( ret.end(), s.cbegin(), s.cend() );
    }

   return ret;
 }