Question

我想使用单个数组或向量来实现多维数组，可以像通常的多维数组一样访问它（例如：a[1][2][3]）。我被困在哪里是如何实现[ ]运算符。如果数组的维数为1，则a [1]应该返回位于索引1的元素。但是如果维度大于1，该怎么办？如果是嵌套向量，比如3维向量，vec[1]将返回vector<vector<some type> >。

我试图实现自己的多维数组的原因是我不知道数组在编译时的维度。维度实际上取决于某些条件。实际上，数组的最大维数是3，所以我可以定义三个不同的向量，但我个人认为这不是正确的选择。

Answer 1

operator[]只能使用一个参数。

最佳解决方案是使用operator()代替。

如果您绝对想要使用operator[]，那么您可以让它返回一个特定于维度的类型的代理对象，可以再次应用operator[]，依此类推。

这是一个常见问题，在C ++常见问题解答“How do I create a subscript operator for a Matrix class?”中得到解答（该链接指向常见问题的主要英文版本）。

在询问之前咨询常见问题解答通常是个好主意。

Answer 2

必须在编译时知道任何表达式的类型。 a[1][2][3]必须具有特定类型。类型不可能在int和vector<int>之间变化，具体取决于运行时输入。

让a[1][2][3]做某事当然是可行的，但这必须返回一个给定类型的对象，你在运行时查询它的属性，看看发生了什么。（例如，运行时维度为1的数组;如果请求的维数太多，则抛出异常）。

正如其他人所指出的那样，经验表明，在一次通话a(1, 2, 3)中，所有维度的编码都较少，而且在运行时也更有效。如果使用operator[]然后记住运算符是函数调用，那么正在进行的是a.operator[](1).operator[](2).operator[](3)，额外的函数调用可能会使编译器难以优化。

另一种选择是让参数在vector之类的容器中传递，即用户可以调用a( vec );，其中vec是包含坐标的向量。

Answer 3

你可以制作一个矢量数组

#include<string>
#include<vetor>
using namespace std;
int main()
{
  vector<int> a;
  vector<vector<int> >b; // must have space > >
  vector< vector < vector<int> > > c;
  a.push_back(20);
  a.push_back(10);
  b.push_back(a);
  c.push_back(b);

  int x = c[0][0][0];
  int y = c[0][0][1];
  cout<< y << "  "<< x <<endl;
  return 0;
}

Answer 4

您好我写了这个多维矩阵库（它没有完全成熟）它支持像dotproduct和pointwise元素这样的基本操作。

https://github.com/josephjaspers/BlackCat_Tensors

Tensor<float> tensor3 = {3, 4, 5};   -- generates a 3 dimensional tensor
tensor3[1] = 3;                      -- returns the second matrix and sets all the values to 3. 
tensor3[1][2];                       -- returns the second matrx and then then 3rd column of that matrix
tensor3({1,2,3},{2,2});              -- at index 1,2,3, returns a sub-matrix of dimensions 2x2

所有访问者操作符[] (int index)和({initializer_list<int> index},{initializer_list<int> shape})都返回单独的张量，但它们都引用相同的内部数组。因此，您可以从这些sub_tensors修改原始张量。

所有数据都分配在一个阵列上。如果你想使用dotproduct，你需要将它链接到BLAS。这是头文件，它详细介绍了大多数方法。 https://github.com/josephjaspers/BlackCat_Tensors/blob/master/BC_Headers/Tensor.h

在评论中，您想详细说明使用代理对象访问

矩阵/向量

template<typename T>
struct Vector {
 T* data; int sz; 

 Vector<T>(T* data, int size){ 
        this->data = data; 
        this->sz = size; 
 } 
 T& operator[] (int index) { return data[i]; }
}

template<typename T>
struct Matrix {
int row; int col;

 //insert constructor here

 Vector<T> operator[] (int index) {
     return Vector<T>(data[index * row], row); //use col for col-major
 }

}

//递归方法

template class T
class Tensor {
int* shape;
T* data;

    Tensor<T>(int*shape, int order, T* data){
       this->shape = shape;
       this->order = order;
       this->data  = data; 
    }

    Tensor<T> operator [] (int index) {
      return Tensor(shape, order -1, &data[index * shape[order - 2]); // if the order = 2(tensor is a matrix) multiply the `data` index by given param * the number of rows --> ergo returns a column vector)
    }
}

用数组或向量实现多维数组

4 个答案: