多维数组：运算符重载

Question

我有一个带有多维数组的类：

• 可以用这个类创建一、二、...、n 维数组

• 如果数组有 n 维，我想使用 n operator[] 来获取对象：

示例：

A a({2,2,2,2}]; 
a[0][1][1][0] = 5;

但数组不是指向其他向量等的指针向量...

所以我希望 operator[] 返回一个类对象，直到最后一个维度，然后返回一个整数

这是一个高度简化的代码，但它显示了我的问题：

我收到的错误："[Error] cannot convert 'A::B' to 'int' in initialization"

#include <cstddef>     // nullptr_t, ptrdiff_t, size_t
#include <iostream>    // cin, cout...

class A {
    private:
        static int* a;
    public:
        static int dimensions;
        A(int i=0) { 
            dimensions = i;
            a = new int[5];
            for(int j=0; j<5; j++) a[j]=j; 
        };

        class B{
            public:
                B operator[](std::ptrdiff_t);
        };
        class C: public B{
            public:
                int& operator[](std::ptrdiff_t);
        };

        B operator[](std::ptrdiff_t);
};

//int A::count = 0;

A::B A::operator[] (std::ptrdiff_t i) {
    B res;
  if (dimensions <= 1){
    res = C();
}
  else{
    res = B();
  }
  dimensions--;
  return res;
}

A::B A::B::operator[] (std::ptrdiff_t i){
    B res;
    if (dimensions <=1){
        res = B();
    }
    else{
        res = C();
    }
    dimensions--;
    return res;
}

int& A::C::operator[](std::ptrdiff_t i){
    return *(a+i);
}


int main(){
    A* obj = new A(5);
    int res = obj[1][1][1][1][1];
    std::cout<< res << std::endl;
}

Answer 1

operator[] 在obj[1][1]...[1] 中从左到右进行计算，因此obj[1] 返回一个B 对象。假设现在您只有int res = obj[1]，那么您将分配给B 对象（或C 对象，在多次调用[] 的情况下）一个int，但没有从@987654330 转换@ 或 C 到 int。您可能需要编写一个转换运算符，例如

operator int()
{
   // convert to int here
}

对于A、B 和C，因为重载的运算符不会被继承。

我只是通过为A 和B 编写这样的运算符来摆脱你的编译错误（当然我有链接错误，因为有未定义的函数）。

另外，请注意，如果您想编写类似obj[1][1]...[1] = 10 的内容，则需要重载operator=，因为同样没有从int 到A 或您的代理对象的隐式转换。

希望这是有道理的。

PS：另见@Oncaphillis 的评论！

Answer 2

vsoftco 是完全正确的，如果你想实际访问你的元素，你需要实现一个重载运算符。如果您希望它是动态的，这是必要的，这就是您描述它的方式。我实际上认为这是一个有趣的问题，所以我实现了您所描述的模板。我认为它有效，但有些事情可能会略有偏差。代码如下：

template<typename T>
class nDimArray {
    using thisT = nDimArray<T>;

    T                    m_value;
    std::vector<thisT*>  m_children;
public:
    nDimArray(std::vector<T> sizes) {
        assert(sizes.size() != 0);
        int thisSize = sizes[sizes.size() - 1];
        sizes.pop_back();

        m_children.resize(thisSize);
        if(sizes.size() == 0) {
            //initialize elements
            for(auto &c : m_children) {
                c = new nDimArray(T(0));
            }
        } else {
            //initialize children
            for(auto &c : m_children) {
                c = new nDimArray(sizes);
            }
        }
    }
    ~nDimArray() {
        for(auto &c : m_children) {
            delete c;
        }
    }
    nDimArray<T> &operator[](const unsigned int index) {
        assert(!isElement());
        assert(index < m_children.size());
        return *m_children[index];
    }

    //icky dynamic cast operators
    operator T() {
        assert(isElement());
        return m_value;
    }
    T &operator=(T value) {
        assert(isElement());
        m_value = value;
        return m_value;
    }

private:
    nDimArray(T value) {
        m_value = value;
    }

    bool isElement() const {
        return m_children.size() == 0;
    }

    //no implementation yet
    nDimArray(const nDimArray&);
    nDimArray&operator=(const nDimArray&);
};

基本思想是这个类既可以充当数组的数组，也可以充当元素。这意味着实际上一个数组数组可以是一个元素数组！当您想要获取一个值时，它会尝试将其强制转换为一个元素，如果这不起作用，它只会抛出一个断言错误。

希望这是有道理的，当然，如果您有任何问题，请尽管问！事实上，我希望你能问，因为你描述的问题的范围比你想象的要大。

Answer 3

为此使用俄罗斯娃娃风格的模板类可能会很有趣。

// general template where 'd' indicates the number of dimensions of the container
// and 'n' indicates the length of each dimension
// with a bit more template magic, we could probably support each
// dimension being able to have it's own size
template<size_t d, size_t n>
class foo
{
private:
    foo<d-1, n> data[n];
public:
    foo<d-1, n>& operator[](std::ptrdiff_t x)
    {
        return data[x];
    }
};

// a specialization for one dimension. n can still specify the length
template<size_t n>
class foo<1, n>
{
private:
    int data[n];
public:
    int& operator[](std::ptrdiff_t x)
    {
        return data[x];
    }
};

int main(int argc, char** argv)
{
    foo<3, 10> myFoo;
    for(int i=0; i<10; ++i)
        for(int j=0; j<10; ++j)
            for(int k=0; k<10; ++k)
                myFoo[i][j][k] = i*10000 + j*100 + k;

    return myFoo[9][9][9]; // would be 090909 in this case
}

每个维度保留一个前一维度元素的数组。维度 1 使用跟踪一维 int 数组的基本特化。然后维度 2 将保留一个一维数组的数组，D3 将有一个二维数组的数组，等等。然后访问看起来与本机多维数组相同。在我的示例中，我在类中使用了数组。这使得 n 维数组的所有内存都是连续的，并且不需要在类内进行动态分配。但是，您也可以通过动态分配提供相同的功能。