用于非零基数组指针分配的 C++ gcc 扩展？

我正在寻找 gcc 支持的 C++ 语言扩展来启用非从零开始的数组指针的分配。理想情况下我可以简单地写：

#include<iostream>  
using namespace std;

// Allocate elements array[lo..hi-1], and return the new array.
template<typename Elem>
Elem* Create_Array(int lo, int hi)
{
  return new Elem[hi-lo] - lo;
  // FIXME what about [expr.add]/4.
  // How do we create a pointer outside the array bounds?
}

// Deallocate an array previously allocated via Create_Array.
template<typename Elem>
void Destroy_Array(Elem* array, int lo, int hi)
{
  delete[](array + lo);
}


int main() 
{  
  const int LO = 1000000000;
  const int HI = LO + 10;
  int* array = Create_Array<int>(LO, HI);
  for (int i=LO; i<HI; i++)
    array[i] = i;
  for (int i=LO; i<HI; i++)
    cout << array[i] << "\n";
  Destroy_Array(array, LO, HI);
} 

上面的代码似乎可以工作，但不是由 C++ 标准定义的。具体来说，问题是[expr.add]/4 https://timsong-cpp.github.io/cppwp/n4659/expr.add#4:

对整型表达式进行加减运算时 对于指针，结果具有指针操作数的类型。如果 表达式 P 指向带有 n 的数组对象 x 的元素 x[i] 元素，表达式 P + J 和 J + P（其中 J 的值为 j） 如果 0 ≤ i + j ≤ 则指向（可能是假设的）元素 x[i + j] n;否则，行为是未定义的。同样，表达式 P - 如果 0 ≤ i − j，J 指向（可能假设的）元素 x[i − j] ≤ n；否则，行为是未定义的。

换句话说，上面代码中标记为 FIXME 的行的行为未定义，因为它计算的指针超出了范围x[0..n]对于从 0 开始的数组x.

有没有一些--std=...选项gcc告诉它允许直接计算非从零开始的数组指针？

如果没有，是否有一种合理可移植的方式来模拟return new Type[hi-lo] - lo;声明，也许通过转换为long然后回来？ （但我会担心引入更多错误）

此外，是否可以通过仅需要 1 个寄存器来跟踪每个数组的方式来完成此操作，如上面的代码？例如，如果我有array1[i], array2[i], array3[i]这只需要数组指针的 3 个寄存器array1, array2, array3，加上一个注册i？ （类似地，如果冷获取数组引用，我们应该能够直接获取非零基指针，而无需进行计算以在寄存器中建立引用）

假设您在 linux x86-64 上使用 gcc，它支持intptr_t and uintptr_t可以保存任何指针值（有效或无效）并且还支持整数运算的类型。uintptr_t更适合此应用程序，因为它支持mod 2^64 语义 /q/16188263 while intptr_t有 UB 案例。

正如评论中所建议的，我们可以使用它来构建一个重载的类operator[]并执行范围检查：

#include <iostream> 
#include <assert.h>
#include <sstream> // for ostringstream
#include <vector>  // out_of_range
#include <cstdint> // uintptr_t
using namespace std;


// Safe non-zero-based array. Includes bounds checking.
template<typename Elem>
class Array {
  uintptr_t array; // base value for non-zero-based access
  int       lo;    // lowest valid index
  int       hi;    // highest valid index plus 1

public:

  Array(int lo, int hi)
    : array(), lo(lo), hi(hi)
  {
    if (lo > hi)
      {
        ostringstream msg; msg<<"Array(): lo("<<lo<<") > hi("<<hi<< ")";
        throw range_error(msg.str());
      }
    static_assert(sizeof(uintptr_t) == sizeof(void*),
          "Array: uintptr_t size does not match ptr size");
    static_assert(sizeof(ptrdiff_t) == sizeof(uintptr_t),
          "Array: ptrdiff_t size does not match ptr (efficieny issue)");
    Elem* alloc = new Elem[hi-lo];
    assert(alloc); // this is redundant; alloc throws bad_alloc
    array = (uintptr_t)(alloc) - (uintptr_t)(lo * sizeof(Elem));
    // Convert offset to unsigned to avoid overflow UB.
  }


  //////////////////////////////////////////////////////////////////
  // UNCHECKED access utilities (these method names start with "_").

  uintptr_t _get_array(){return array;}
  // Provide direct access to the base pointer (be careful!)

  Elem& _at(ptrdiff_t i)
  {return *(Elem*)(array + (uintptr_t)(i * sizeof(Elem)));}
  // Return reference to element (no bounds checking)
  // On GCC 5.4.0 with -O3, this compiles to an 'lea' instruction

  Elem* _get_alloc(){return &_at(lo);}
  // Return zero-based array that was allocated

  ~Array() {delete[](_get_alloc());}


  //////////////////////////////
  // SAFE access utilities

  Elem& at(ptrdiff_t i)
  {
    if (i < lo || i >= hi)
      {
        ostringstream msg;
        msg << "Array.at(): " << i << " is not in range ["
            << lo << ", " << hi << "]";
        throw out_of_range(msg.str());
      }
    return _at(i);
  }

  int get_lo() const {return lo;}
  int get_hi() const {return hi;}
  int size()   const {return hi - lo;}

  Elem& operator[](ptrdiff_t i){return at(i);}
  // std::vector is wrong; operator[] is the typical use and should be safe.
  // It's good practice to fix mistakes as we go along.

};


// Test
int main() 
{  
  const int LO = 1000000000;
  const int HI = LO + 10;
  Array<int> array(LO, HI);
  for (int i=LO; i<HI; i++)
    array[i] = i;
  for (int i=LO; i<HI; i++)
    cout << array[i] << "\n";
}

请注意，仍然无法强制转换由以下方法计算出的无效“指针”intptr_t到指针类型，由于GCC 4.7 数组和指针 https://gcc.gnu.org/onlinedocs/gcc/Arrays-and-pointers-implementation.html:

当从指针转换为整数并再次返回时，结果指针必须引用与原始指针相同的对象，否则行为未定义。也就是说，不能使用整数算术来避免 C99 和 C11 6.5.6/8 中所禁止的指针算术的未定义行为。

这就是为什么array字段必须是类型intptr_t并不是Elem*。换句话说，只要行为被定义intptr_t调整为在转换回之前指向原始对象Elem*.