Как найти адрес элемента массива

N-Dimensional Arrays: The N-Dimensional array is basically an array of arrays. As 1-D arrays are identified as a single index, 2-D arrays are identified using two indices, similarly, N-Dimensional arrays are identified using N indices. A multi-dimensional array is declared as follows:

int NDA[S₁][S₂][S₃]……..[S_N];

Explanation:

• Here, NDA is the name of the N-Dimensional array. It can be any valid identifier name.
• In the above syntax, S₁, S₂, S₃……S_N denotes the max sizes of the N dimensions.
• The lower bounds are assumed to be zeroes for all the dimensions.
• The above array is declared as an integer array. It can be any valid data type other than an integer as well.

Address Calculation of N-Dimensional Arrays:

Assumptions:

• The N-Dimensional array NDA with the maximum sizes of N dimensions are S₁, S₂, S₃, ………, S_N.
• The element whose address needs to be calculated has indices l₁, l₂, l₃, …………..l_N respectively.
• It is possible that the array indices do not have the lower bound as zero. For example, consider the following array T: T[-5…5][2……9][14…54][-9…-2].

Explanation:

• In the above array T, the lower bounds of indices are not zeroes.
• So that the sizes of the indices of the array are different now and can be calculated by using the formula:

UpperBound – LowerBound +1

• So, here the S₁ = 5 – (-5) + 1 = 11. Similarly, S₂ = 8, S₃ = 41 and S₄ = 8.

For address calculation, the lower bounds are t₁, t₂, t₃…….t_N. There exist two ways to store the array elements:

• Row Major
• Column Major

The Column Major formula:

Address of NDA[I₁][I₂]. . . [I_N] = BAd + W*[((…E_NS_N-1+ E_N-1 )S_N-2 +… E₃ )S₂+ E₂ )S₁ +E₁]

• BAd represents the base address of the array.
• W is Storage Size of one element stored in the array (in byte).
• Also, E_i is given by E_i  = l_i – t_i, where l_i and t_i are the calculated indexes (indices of array element which needs to be determined) and lower bounds respectively.

The Row Major formula:

Address of NDA[I₁][I₂]. . . .[l_N] = BAd + W*[((E₁S₂ + E₂ )S₃ +E₃ )S₄ ….. + E_N-1 )S_N + E_N]

The simplest way to learn the formulas:

For row-major: If width = 5, the interior sequence is E₁S₂ + E₂S₃ + E₃S₄ + E₄S₅ + E₅ and if width = 3, the interior sequence is E₁S₂ + E₂S₃ + E₃. Figure out the pattern in the order and follow four basic steps for the formula of any width:

• Write the interior sequence.
• Put the closing bracket after each E except the first term. So for width = 5, it becomes

E₁S₂ + E₂)S₃ + E₃)S₄ + E₄)S₅ + E₅).

• Put all the Opening brackets initially.

((((E₁S₂ + E₂)S₃ + E₃)S₄ + E₄)S₅ + E₅).

• Incorporate the base address and width in the formula.

The approach is similar for the Column Major but the pattern of the interior sequence is reverse of the row-major pattern. 

For column-major: If width =5, the interior sequence is E₅S₄ + E₄S₃ + E₃S₂+ E₂S₁ + E₁.

Example: Let’s take a multi-dimensional array A[10][20][30][40] with the base address 1200. The task is to find the address of element A[1][3][5][6].

Here, BAd = 1200 and width = 4.
S1 = 10, S2 = 20, S3 = 30, S4 = 40

Since the lower bounds are not given, so lower bounds are assumed to be zero.
E1 = 1 – 0 = 1; 
E2 = 3 – 0 = 3; 
E3 = 5 – 0 = 5;
E4 = 6 – 0 = 6.

Any of the techniques (Row-major or column-major) can be used for calculating the answer (unless specified). 
By applying the formula for row-major, directly write the formula as:

A[1][3][5][6] = 1200 + 4(((1 × 20 + 3)30 +5)40 + 6) 

 =1200 +4((23 × 30 +5)40 +6) 

=1200 + 4(695 × 40 + 6) 

=1200 + (4 × 27806) 

=112424.

Last Updated :
20 Sep, 2022

Like Article

Save Article

Если у вас есть указатель вида

T *p;

то 1) для арифметики указателей используется значение sizeof( T ), и 2) разыменование указателя дает lvalue , на который указывает указатель.

Например, если имеется следующий фрагмент кода

int a[] = { 1, 2 };
int *p = &a[0];

то значение указателя после выполнения выражения ++p будет равно

значение указателя перед инкрементом плюс значение sizeof( int )

В этом случае в результате указатель будет указывать на элемент a[1].

Если имеется объявление следующего массива

char array[] = "String";

то оно эквивалентно следующему объявлению массива

char array[7] = "String";

Если ввести typedef объявление

typedef char T[7];

то объявление вышеприведенного массива можно записать также как

T array = "String";

Поэтому чтобы объявить указатель на этот объект, следует записать

T *p = &array;

И, как показано выше, для арифметики указателей для указателя p используется выражение sizeof( T ) , которое равно sizeof( char[7] ).

Разыменовывая этот указатель, вы получите lvalue объекта типа char[7]

Это легко проверить, выполнив предложение

printf( "%zun", sizeof( *p ) );

результатом которого будет значение 7, то есть получена длина массива типа char[7].

Однако когда в качестве объекта, полученного после разыменования указателя, имеется массив, то он в выражения за редким исключением преобразуется к указателю на свой первый элемент.

Из стандарта C (6.3.2.1 Lvalues, arrays, and function designators)

3 Except when it is the operand of the sizeof operator or the unary &
operator, or is a string literal used to initialize an array, an
expression that has type ‘‘array of type’’ is converted to an
expression with type ‘‘pointer to type’’ that points to the initial
element of the array object and is not an lvalue. If the array object
has register storage class, the behavior is undefined.

Поэтому для вышеприведенного примера если выражение *p, не используется в качестве операнда оператора sizeof или оператора &, то происходит неявное преобразование полученного массива в указатель на свой первый элемент. Поэтому, например, выражение **p даст объект типа char со значением 'S'.

Указатели, массивы и строки

Последнее обновление: 05.01.2023

В языке Си массивы и указатели тесно связаны. С помощью указателей мы также легко можем манипулировать элементами массива, как и с помощью индексов.

Имя массива без индексов в Си является адресом его первого элемента. Соответственно через операцию разыменования мы можем получить значение по этому адресу:

#include <stdio.h>

int main(void)
{
	int array[] = {1, 2, 3, 4, 5};
	printf("array[0] = %d", *array);	// array[0] = 1

    return 0;
}

Мы можем пробежаться по всем элементом массива, прибавляя к адресу определенное число:

#include <stdio.h>

int main(void)
{
    int array[5] = {1, 2, 3, 4, 5};
     
    for(int i = 0; i < 5; i++)
    {
        void* address = array + i;  // получаем адрес i-го элемента массива
        int value = *(array + i);   // получаем значение i-го элемента массива
        printf("array[%d]: address=%p t value=%d n", i, address, value);
    }
    return 0;
}

То есть, например, адрес второго элемента будет представлять выражение a+1, а его значение – *(a+1).

Со сложением и вычитанием здесь действуют те же правила, что и в операциях с указателями. Добавление единицы означает прибавление к адресу
значения, которое равно размеру типа массива. Так, в данном случае массив представляет тип int, размер которого, как правило, составляет 4 байта,
поэтому прибавление единицы к адресу означает увеличение адреса на 4. Прибавляя к адресу 2, мы увеличиваем значение адреса на 4 * 2 =8. И так далее.

В итоге в моем случае я получу следующий результат работы программы:

array[0]: address=0060FE98	value=1
array[1]: address=0060FE9C	value=2
array[2]: address=0060FEA0	value=3
array[3]: address=0060FEA4	value=4
array[4]: address=0060FEA8	value=5

В то же время имя массива это не стандартный указатель, мы не можем изменить его адрес, например, так:

int array[5] = {1, 2, 3, 4, 5};
array++;			// так сделать нельзя
int b = 8;
array = &b;			// так тоже сделать нельзя

Использование указателя для работы с массивом

Имя массива всегда хранит адрес самого первого элемента, соответственно его можно присвоить другому указателю и затем через указатель обращаться к элеиментам массива:

#include <stdio.h>
 
int main(void)
{
    int array[5] = {1, 2, 3, 4, 5};
    int *ptr = array;	// указатель ptr хранит адрес первого элемента массива array
    printf("value: %d n", *ptr);	// 1
    return 0;
}

Прибавляя (или вычитая) определенное число от адреса указателя, можно переходить по элементам массива. Например, перейдем к третьему элементу:

#include <stdio.h>
 
int main(void)
{
    int array[5] = {1, 2, 3, 4, 5};
    int *ptr = array;	// указатель ptr хранит адрес первого элемента массива array
    ptr = ptr + 2;      // перемезаем указатель на 2 элемента вперед
    printf("value: %d n", *ptr);	// value: 3
    return 0;
}

Здесь указатель ptr изначально указывает на первый элемент массива. Увеличив указатель на 2, мы пропустим 2 элемента в массиве и
перейдем к элементу array[2].

И как и другие данные, можно по указателю изменить значение элемента массива:

#include <stdio.h>
 
int main(void)
{
    int array[5] = {1, 2, 3, 4, 5};
    int *ptr = array;	    // указатель ptr хранит адрес первого элемента массива array
    ptr = ptr + 2;          // переходим к третьему элементу
    *ptr = 8;               // меняем значение элемента, на который указывает указатель

    printf("array[2]: %d n", array[2]);	// array[2] : 8
    return 0;
}

Стоит отметить, что указатель также может использовать индексы, как и массивы:

#include <stdio.h>
 
int main(void)
{
    int array[5] = {1, 2, 3, 4, 5};
    int *ptr = array;	    // указатель ptr хранит адрес первого элемента массива array

    int value = ptr[2];     // используем индексы - получаем 3-й элемент (элемент с индексом 2)

    printf("value: %d n", value);	// value: 3
    return 0;
}

Строки и указатели

Ранее мы рассмотрели, что строка по сути является набором символов, окончанием которого служит нулевой символ ”. И фактически строку можно представить в виде массива:

char hello[] = "Hello METANIT.COM!";

Но в языке Си также для представления строк можно использовать указатели на тип char:

#include <stdio.h>
 
int main(void)
{
	char *hello = "Hello METANIT.COM!";	// указатель на char - фактически строка
	printf("%s", hello);
	return 0;
}

Оба определения строки – с помощью массива и указателя будут в равнозначны здесь будут равнозначны.

Перебор массива с помощью указателей

С помощью указателей легко перебрать массив:

int array[5] = {1, 2, 3, 4, 5};

for(int *ptr=array; ptr<=&array[4]; ptr++)
{
	printf("address=%p t value=%d n", (void*)ptr, *ptr);
}

Так как указатель хранит адрес, то мы можем продолжать цикл, пока адрес в указателе не станет равным адресу последнего элемента (ptr<=&array[4]).

Аналогичным образом можно перебрать и многомерный массив:

#include <stdio.h>

int main(void)
{
	int array[3][4] = { {1, 2, 3, 4} , {5, 6, 7, 8}, {9, 10, 11, 12}};
	int n = sizeof(array)/sizeof(array[0]); 		// число строк
	int m = sizeof(array[0])/sizeof(array[0][0]);	// число столбцов
	
	int *final = array[0] + n * m - 1;	// указатель на самый последний элемент
	for(int *ptr=array[0], i = 1; ptr <= final; ptr++, i++)
	{
		printf("%d t", *ptr);
		// если остаток от целочисленного деления равен 0,
		// переходим на новую строку
		if(i%m==0)
		{
			printf("n");
		}
	}	
	return 0;
}

Так как в данном случае мы имеем дело с двухмерным массивом, то адресом первого элемента будет выражение array[0]. Соответственно указатель указывает на
этот элемент. С каждой итерацией указатель увеличивается на единицу, пока его значение не станет равным адресу последнего элемента, который хранится в
указателе final.

Мы также могли бы обойтись и без указателя на последний элемент, проверяя значение счетчика, пока оно не станет равно общему количеству элементов (m * n):

for(int *ptr = array[0], i = 0; i < m*n;)
{
	printf("%d t", *ptr++);
	if(++i%m==0)
	{
		printf("n");
	}
}

Но в любом случае программа вывела бы следующий результат:

1	2	3	4
5	6	7	8
9	10	11	12