Как рассчитать шаг между двумя элементами в двумерном массиве размером 1000 на 1000? C ++ - PullRequest
Новая
       31

Как рассчитать шаг между двумя элементами в двумерном массиве размером 1000 на 1000? C ++

0 голосов
/ 17 октября 2019

Я пытаюсь найти шаг между индексом [0][0] и [0][1], а также между [0][0] и [1][0], чтобы попытаться понять, как это работает, поэтому я печатаю адрес памятикаждого из них, а затем получить разницу, что я понимаю, как быть.

То есть: адрес памяти в [0][0] равен 0x00E8C140, а адрес памяти в [0][1] равен 0x00E8C148, поэтому шаг должен быть 8, верно? (Массив имеет размер 2D массива [1000][1000]) 

for (int y = 0; y < 1000; ++y)
{
    for (int x = 0; x < 1000; ++x)
    {
        Array[y][x] = (x == y) ? 1.0 : 0.0;
        if (y == 0 && x == 0) {
            printf("&Array[%d][%d]=%p\n",y, x, &Array[y][x]);
        }
        if (y == 0 && x == 1) {
            printf("&Array[%d][%d]=%p\n",y, x, &Array[y][x]);
        }
        if (y == 1 && x == 0) {
            printf("&Array[%d][%d]=%p\n", y, x, &Array[y][x]);
        }
    }
}

Вывод: 

&Array[0][0]=00E8C140
&Array[0][1]=00E8C148
&Array[1][0]=00E8E080

Я имею в виду, что для меня это имеет смысл, но я даже не уверен, чтона самом деле печатать адрес памяти правильно, потому что это так много. Я бы подумал, что базовый адрес ([0][0]) будет примерно 1000 или что-то в этом роде.

1 Ответ

2 голосов
/ 17 октября 2019

Разница между массивом [0] [1] и массивом [0] [0] составляет один элемент массива. Размер разницы не зависит от размера элемента массива. Таким образом, для массива, содержащего char, разница будет равна 1, а для массива, содержащего long, это будет 8 на 64-битной машине.

Разница между массивом [1] [0] и массивом [0] [0] состоит в том, что многие элементы массива находятся в строке (для массива 1000 x 1000 это будет 1000 элементов массива). Размер разницы - это любой размер элемента массива, умноженный на количество элементов массива в строке. Таким образом, для массива 1000 x 1000, содержащего char, разница будет равна 1 x 1000, а для массива того же размера, содержащего long, он будет 8 x 1000 на 64-битной машине.

Вот пример программы, которая использует массивы 10 x 10: 

#include <stdio.h>

int main()
{
    #define ARRAY_WIDTH 10
    #define ARRAY_HEIGHT 10
    char CArray[ARRAY_HEIGHT][ARRAY_WIDTH];
    short SArray[ARRAY_HEIGHT][ARRAY_WIDTH];
    long LArray[ARRAY_HEIGHT][ARRAY_WIDTH];

    printf("&CArray[0][1] - &CArray[0][0] = %ld (%p-%p)  sizeof(char) = %lu\n",
            (long)(&CArray[0][1]) - (long)(&CArray[0][0]), &CArray[0][1], &CArray[0][0], sizeof(char));
    printf("&SArray[0][1] - &SArray[0][0] = %ld (%p-%p)  sizeof(short) = %lu\n",
            (long)(&SArray[0][1]) - (long)(&SArray[0][0]), &SArray[0][1], &SArray[0][0], sizeof(short));
    printf("&LArray[0][1] - &LArray[0][0] = %ld (%p-%p)  sizeof(long) = %lu\n",
            (long)(&LArray[0][1]) - (long)(&LArray[0][0]), &LArray[0][1], &LArray[0][0], sizeof(long));

    printf("&CArray[1][0] - &CArray[0][0] = %ld (%p-%p)  sizeof(char) * ARRAY_WIDTH = %lu\n",
            (long)(&CArray[1][0]) - (long)(&CArray[0][0]), &CArray[1][0], &CArray[0][0], sizeof(char) * ARRAY_WIDTH);
    printf("&SArray[1][0] - &SArray[0][0] = %ld (%p-%p)  sizeof(short) * ARRAY_WIDTH = %lu\n",
            (long)(&SArray[1][0]) - (long)(&SArray[0][0]), &SArray[1][0], &SArray[0][0], sizeof(short) * ARRAY_WIDTH);
    printf("&LArray[1][0] - &LArray[0][0] = %ld (%p-%p)  sizeof(long) * ARRAY_WIDTH = %lu\n",
            (long)(&LArray[1][0]) - (long)(&LArray[0][0]), &LArray[1][0], &LArray[0][0], sizeof(long) * ARRAY_WIDTH);

    return 0;
}

Эта программа выдает следующий вывод (помните, что мои массивы только 10 x 10): 

&CArray[0][1] - &CArray[0][0] = 1 (0x7ffcff4045e1-0x7ffcff4045e0)  sizeof(char) = 1                                                           
&SArray[0][1] - &SArray[0][0] = 2 (0x7ffcff404652-0x7ffcff404650)  sizeof(short) = 2                                                          
&LArray[0][1] - &LArray[0][0] = 8 (0x7ffcff404728-0x7ffcff404720)  sizeof(long) = 8                                                           
&CArray[1][0] - &CArray[0][0] = 10 (0x7ffcff4045ea-0x7ffcff4045e0)  sizeof(char) * ARRAY_WIDTH = 10                                           
&SArray[1][0] - &SArray[0][0] = 20 (0x7ffcff404664-0x7ffcff404650)  sizeof(short) * ARRAY_WIDTH = 20                                          
&LArray[1][0] - &LArray[0][0] = 80 (0x7ffcff404770-0x7ffcff404720)  sizeof(long) * ARRAY_WIDTH = 80

Посмотрите здесь: https://onlinegdb.com/BJwpNDBYB

...