C++ 不允许带有负索引的向量？

Question

我试图创建一些带有负索引的向量，但刚刚得知它在 C++ 中是不允许的。是否有任何替代或更好的方法来做到这一点？

例如我想创建一个名为 Wt 的 3D 矢量：

在 VBA 上下文数组中是这样构建的：简单而漂亮

Redim Wt(0 to k_max,-i_max to i_max,-j_max to j_max)
' and use it like below for example: 
Wt(3, -100, -105) = .....

在 C++ 上下文中，它既不友好又不方便：

// resizing the vector:
Wt.resize(k_max + 1);
for (int k = 0; k < k_max + 1; k++) {
    Wt[k].resize(2 * i_max + 1);
    for (int i = 0; i < 2 * i_max + 1; i++) {
        Wt[k][i].resize(2 * j_max + 1);
    }
}

// when using the vector:
for (int k = 0; k <= k_max; k++) {
    for (int i = -i_max; i <= i_max; i++) {
        for (int j = -j_max; j <= j_max; j++) {
            Wt[k][i + i_max][j + j_max] = ...
        }
    }
}

Answer 1

不，您需要自己移动索引或实现一个为您移动它的类。如果需要，这里是代码

#include <iostream>
#include<vector>
#include <stdexcept>
using namespace std;


class FriendlyArray{
    int _maxIndex;
    int _minIndex;
    vector<int> _data;
    public:
        FriendlyArray(int minIndex, int maxIndex)
        {
            _maxIndex=maxIndex;
            _minIndex=minIndex;
            _data=vector<int>(_maxIndex-_minIndex+1);
        }
    public:
      int& operator[] (int x) {
          if (x<_minIndex || x> _maxIndex)
            throw std::logic_error( "Exception example" ); 
          else {
              return _data[x-_minIndex];
          }
      } 
};

int main() {
    FriendlyArray example(-1,11);
    example[-1]=4;
    cout<<example[-1]<<endl;
    // your code goes here
    return 0;
}

输出：4，如预期的那样

如果你想要一个更通用的版本，你会得到

#include <iostream>
#include<vector>
#include <stdexcept>
#include <assert.h>
using namespace std;


template<typename T> class FriendlyArray{
    const int _maxIndex;
    const int _minIndex;
    vector<T> _data;
    public:
        FriendlyArray(int minIndex, int maxIndex):
        _minIndex(minIndex),
        _maxIndex(maxIndex)
        {
            _data=vector<T>(_maxIndex-_minIndex+1);
        }
    public:
      T& operator[] (int x){
          assert(!(x<_minIndex || x> _maxIndex));
          return _data[x-_minIndex];
      } 
};

int main() {
    FriendlyArray<int> example(-1,11);
    example[-1]=4;
    cout<<example[-1]<<endl;

    FriendlyArray<double> example2(-2,20);
    example2[-2]=0.5;
    cout<<example2[-2];
    return 0;
}

输出（如预期）： 4 0.5