C++ 从非0的数字开始的数组索引

是否可以在索引不为零的位置启动数组…即。 你有一个由35个元素组成的数组a[35]，现在我想在100开始处建立索引，所以数字应该是a[100]，a[101]。。。a[134]，这可能吗

我试图为一块板生成一个“内存映射”，例如，我将有一个称为SRAM[10000]的数组和另一个称为BRAM[5000]的数组，但在“内存”可见性中，它们是连续的，即BRAM在SRAM之后立即启动，所以，如果我试图指向内存位置11000，我会读取它，看到它超过10000，然后将它传递给bram

当我输入这个时，我意识到我可以从数字中减去10K，然后将其传递到BRAM，但是为了论证，这是否可能将11000传递到BRAM

谢谢你的帮助

更新以将a[34]修正为a[134]

更新以获取更多信息：

---

在我将要实现的实际体系结构中，sram和bram之间可能存在差距，例如，地址11008可能在内存映射中不可见，因此写入一个充满内存的巨大阵列，然后“分区”它将工作，但我仍然必须进行逻辑分析，以确定它是否在“sram和bram”的范围内。这是我首先想要避免的。

不是C语言。你必须自己做算术。可能有一些奇怪的解决方法在大多数情况下都有效，比如制作一个新的BRAM-11000指针并使用它

C++在这方面提供了比C多得多的功能。您可以重载

运算符[]

来执行减法，如果下标超出范围，您还可以报告错误（例如抛出异常）

作为一个最小的演示，请考虑以下内容：

#include <iostream>
#include <stdexcept>

template <class T, int lower, int upper>
class array {
    T data[upper-lower];
public:
    T &operator[](int index) { 
        if (index < lower || index >= upper)
            throw std::range_error("Index out of range");
        return data[index-lower]; 
    }
    T *begin() { return data; }
    T *end() { return data + (upper-lower); }
};

int main() {
    array<int, -3, 5> data;

    for (int i=-3; i<5; i++)
        data[i] = i;

    for (auto const &i : data) 
        std::cout << i << "\t";
    std::cout << "\n";
}

#包括
#包括
模板
类数组{
T数据[上下]；
公众：
T&运算符[]（int索引）{
如果（索引<下| |索引>=上）
抛出标准：：范围_错误（“索引超出范围”）；
返回数据[指数较低]；
}
T*begin（）{返回数据；}
T*end（）{返回数据+（上下）；}
};
int main（）{
阵列数据；
对于（inti=-3；iNo-as-in，不能修改VB6等声明中的下限

是的，就像你可以做的那样

int a[35];
int* actual_a = a-100;
printf("%d", actual_a[101]);
...

因为
x[a]
相当于
*（x+a）
。这是非常不值得推荐的。
是否可以在索引不为零的位置开始一个数组…即，您有一个包含35个元素的数组a[35]，现在我想在索引开始时说是100，所以数字应该是a[100]，a[101]，…a[134]，这是可能的吗

<>不，你不能在C数组中这样做。总是在0开始。在C++中，你可以编写自己的类，比如说“代码> OffStReals< /Cord>”，并重载<代码> []/Cord>运算符，访问基础数组，同时从索引中减去偏移量。

我正在尝试为一块板生成一个“内存映射”，例如，我将有一个名为SRAM[10000]的数组和另一个名为BRAM[5000]的数组，但在“内存”中可见，它们是连续的，即BRAM在SRAM之后启动，因此，如果我尝试指向内存位置11000，我会读取它，看到它超过10000，然后将它传递给BRAM

您可以尝试以下方法：

char memory[150000];
char *sram = &memory[0];
char *bram = &memory[100000];

int* myArray = malloc((upperBound - lowerBound) * sizeof(*myArray));
myArray -= lowerBound;
...
for(int i = lowerBound; i < upperBound; i++) {
    myArray[i];
}

现在，当您访问
sram[110000]
时，您将访问“在
bram
中”的内容您可以用宏作弊：

int myarray[35];

#define a (myarray - 100)

a[100] = 0;

也可以使用指针。
最简单的方法是：

你有：

int *array = memory ; // starts with 0;
array-= 1000 ; // now array[1000] is 0

在C++中，用<代码>操作符[][COD]>/P>< /P> < P>指针和数组在C中非常相似，这样就可以很容易地做一些类似
的事情。
element SRAM_MEM[10000];
element BRAM_MEM[5000];

element* SRAM = SRAM_MEM;
element* BRAM = BRAM_MEM-10000;

BRAM[10001] = 0; // sets the first element of BRAM_MEM

您不太清楚如何使用这些数组，但设置一个连续的数组很容易，它可以显示为两个不同的数组：

int   ram[15000]; 
int * sram=&ram[0];
int * bram=&ram[10000];

我使用了&foo[xxx]表示法只是为了明确说明您在做什么。无论如何，您现在可以使用ram索引整个阵列的任何位置，或者使用sram和bram索引特定部分。
只要有一个考虑到偏移量的变量。即使可能，拥有一个不从传统0开始的阵列也将非常不可读。
I rem余烬在《C编程专家-深层C秘密》一书中，Peter Van der Linden披露了一个欺骗编译器认为数组偏移量从1开始的技巧…理论上，这个技巧是可以实现的，我没有这本书，但我记得当时读过它…它不可移植，可能会产生未定义的行为

编辑：请参见C-FAQ第6.17节。警告：不可移植和未定义的行为！
引自这里

6.17：这里有一个巧妙的技巧：
如果我写int realarray[10]；
int*array=&realarray[-1]；
我可以把“数组”当作一个基于1的数组来对待。答：虽然这种技术
很有吸引力（在《C_中的数字配方》一书的旧版本中使用），
它不严格符合C标准。定义了指针算法
只要指针指向同一个分配的内存块，
或者到假想的“终止”元素，超过它一个；否则，行为
未定义，*即使指针未取消引用*。上述代码可能
如果在减去偏移量时生成非法地址，则失败
（可能是因为该地址试图“环绕”过去某个时间的开头。）
内存段）。
参考文献：K&R2第5.3节第100页，第5.4节第102-3页，第A7.7节第205-6页；
ISO第6.3.6节；基本原理第3.2.2.3节。
阅读更多：http://www.faqs.org/faqs/C-faq/faq/#ixzz0ftyqHOvm
希望这会有所帮助。
严格来说，此解决方案不会让您定义从不同于0的索引开始的数组，但您可以这样声明内存：

typedef union
{
    unsigned char all[15000];
    struct
    {
        unsigned char sram[10000];
        unsigned char bram[5000];
    };
} memory;

这确实表明内存是连续的，并且分为两部分。请注意，您应该注意
bram
和
sram
的对齐，可能会出现
#pragma包（1）
#pragma pack(0)
union 
{
  char array[15000];
  struct { char sram[10000]; char bram[5000];  } map;
} combination;

int* myArray = malloc((upperBound - lowerBound) * sizeof(*myArray));
myArray -= lowerBound;
...
for(int i = lowerBound; i < upperBound; i++) {
    myArray[i];
}

int* fancyIntArray(size_t lowerBound, size_t upperBound) {
    return intMalloc(upperBound - lowerBound) - lowerBound;
}

int* intMalloc(size_t size) {
    return malloc(size_t*sizeof(int));
}