Индексация массива, запускающаяся в числе не 0

] 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";
}

Я помню, как читал в книге «Экспертное программирование на C - секреты Deep C», Питер Ван дер Линден раскрывает уловку, позволяющую обмануть компилятор, заставляя думать, что смещения массива начинаются с 1 ... теоретически трюк может быть выполнен, я не Возьмите книгу с собой, но я вспомнил, что читал ее ... она не переносима и может приводить к неопределенному поведению ...

Изменить: См. здесь раздел 6.17 в C-FAQ. ВНИМАНИЕ: Непереносимое и неопределенное поведение! Цитата из источника здесь.

6.17: Here's a neat trick: 
      if I write int realarray[10]; 
         int *array = &realarray[-1]; 
I can treat "array" as if it were a 1-based array. A: Although this technique 
is attractive (and was used in old editions of the book _Numerical Recipes in C_), 
it is not strictly conforming to the C Standard. Pointer arithmetic is defined 
only as long as the pointer points within the same allocated block of memory, 
or to the imaginary "terminating" element one past it; otherwise, the behavior 
is undefined, *even if the pointer is not dereferenced*. The code above could 
fail if, while subtracting the offset, an illegal address were generated 
(perhaps because the address tried to "wrap around" past the beginning of some 
memory segment). 

References: K&R2 Sec. 5.3 p. 100, Sec. 5.4 pp. 102-3, Sec. A7.7 pp. 205-6; 
ISO Sec. 6.3.6; Rationale Sec. 3.2.2.3.

Read more: http://www.faqs.org/faqs/C-faq/faq/#ixzz0ftyqHOvm

Надеюсь, это поможет.

Нет - поскольку вы не можете изменить нижнюю границу в объявлении, например VB6.

Да - например, вы можете выполнять трюки вроде

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

, потому что x [a] эквивалентно * (x + a) . Это крайне не рекомендуется.

You ' re не очень ясно, как именно вы хотите использовать эти массивы, но достаточно легко настроить один непрерывный массив, который может выглядеть как два разных массива:

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

Я использовал нотацию & foo [xxx], чтобы сделать это явным что ты делаешь. В любом случае теперь вы можете использовать ram для индексации в любом месте всего массива или sram и bram для индексации в определенных частях.

Просто имейте переменную, которая учитывает смещение. Даже если возможно, наличие массива, который не начинается с обычного 0, будет крайне нечитаемым.

Можно схитрить с макросом:

int myarray[35];

#define a (myarray - 100)

a[100] = 0;

Можно также использовать указатель.

строго говоря, это решение не позволяет вам определять массив, начинающийся с индекса, отличного от 0, но вы можете объявить свою память следующим образом:

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

это действительно передает намерение, что память является непрерывной и что она разделить на 2 части. обратите внимание, что вам следует остерегаться выравнивания bram и sram , может потребоваться #pragma pack (1) .

Не в C. Вы должны сами выполнять арифметические операции. Вероятно, есть причудливые обходные пути, которые работают большую часть времени, например, создание нового указателя, который является BRAM-11000, и его использование вместо него.

Самый простой способ сделать это:

у вас есть:

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

В C ++ просто создайте класс с помощью оператора []

Указатели и массивы очень похожи в 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

Может быть, вы можете использовать union?

#pragma pack(0)
union 
{
  char array[15000];
  struct { char sram[10000]; char bram[5000];  } map;
} combination;

Они есть физически смежные. Если вы обращаетесь к 'array', тогда он перейдет в bram или sram в зависимости от смещения

. Вам нужна прагма, чтобы сообщить компилятору НЕ выравнивать элементы структуры по границам слова. Это предотвращает появление большого количества байтов между двумя частями структуры карты.