Тема 6. Составные типы данных
Данные регулярного типа (массивы)
Массивом называется структура данных, позволяющая хранить под одним именем совокупность (последовательность) данных (переменных) любого, но только одного какого–то типа. Массив характеризуется размерностью, своим именем, базовым типом хранимых элементов, размером и способом нумерации элементов.
Имя массива – общее имя переменных, входящих в массив.
Базовый тип массива – тип переменных, входящих в массив.
Элементы массива – переменные, входящие в массив.
В тексте программы элементы массива изображаются в виде переменных с индексами. Индексы записываются в квадратных скобках сразу после имени массива и разделяются между собой запятыми. Имя массива совпадает с именем переменной с индексами, т.е. с именем элемента массива. Конкретные значения индексов определяют положение элемента в массиве и однозначно идентифицируют его.
Размерность массива – количество индексов, которое необходимо для однозначной идентификации любого элемента массива.
Размер массива – общее количество элементов в массиве.
На практике довольно часто используют одномерные и двухмерные массивы. Одномерный массив иногда называют вектором, двумерный – матрицей. Одномерный массив удобно представлять в виде группы последовательных ячеек памяти, а матрицу – в виде квадратной таблицы.
Статические массивы можно объявлять с инициализацией, перечисляя значения их элементов в {} через запятую. Если задано меньше элементов, чем длина массива остальные элементы считаются нулями:
int a10[10] = { 1, 2, 3, 4 }; /* и 6 нулей */
Если при описании массива с инициализацией не указать его размер, он будет подсчитан компилятором:
int a3[] = { 1, 2, 3 }; /* как бы a3[3] */
Массивы определяются с помощью синтаксической конструкции, показанной на рис.27.
Тип элемента может быть любым допустимым типом языка Си (в том числе и регулярным типом (массивом) тоже), а в качестве типа индекса может использоваться любое выражение, выдающее значение целого типа: char, short, int, long. При описании переменной регулярного типа строго фиксируются границы изменения каждого индекса. В дальнейшем эти границы изменять нельзя. Как правило, индексы массива представляют ограниченный тип на базе целого, а верхняя граница диапазона описывается как константа:
int N = 10;
int M = 20;
float A [N] [M]; // матрица NxM из 200 элементов
int B [N]; // вектор из 10 целых элементов
char C {'A','F',’6’,’5’} // вектор из 4 символьных элементов
В разделе операторов для обращения к элементам описанных массивов могут использоваться переменные с индексами, причем в качестве индексов могут выступать любые выражения, выдающие результат такого же типа, что и соответствующий индекс, например:
A[2,3]:=3.14;
A[i,j]:=i*i+j–2;
A[i,2]:=A[i–1,j+2];
B[j]:=3; B[j+i]:=i+j;
Строки
Строка в Си - это последовательность байт (букв, символов, литер, character), завершающаяся в конце специальным признаком - байтом '\0'. Этот признак добавляется компилятором автоматически, когда мы задаем строку в виде "строка". Длина строки (т.е. число литер, предшествующих '\0') нигде явно не хранится. Длина строки ограничена лишь размером массива, в котором сохранена строка, и может изменяться в процессе работы программы в пределах от 0 до длины массива-1. При передаче строки в качестве аргумента в функцию, функции не требуется знать длину строки, т.к. передается указатель на начало массива, а наличие ограничителя '\0' позволяет обнаружить конец строки при ее просмотре. В табл.8 представлены строковые типы данных.
Таблица 8.
Строковые типы данных в языке Си
| Тип | Размер в байтах (битах) | Диапазон значений | Знаковый (может ли хранить отрицательные числа) |
| Char | 1 (8) | от -128 до 127 | Да |
| Unsigned char | 1 (8) | от 0 до 255 | Нет |
| Signed char | 1 (8) | от -128 до 127 | Да |
Базовым типом данных является Char. Объект этого базового типа может быть модифицирован с помощью следующих модификаторов: unsigned, signed.
Язык Си позволяет определить строки двумя различными способами. В первом используется массив символов, а во втором - указатель на первый символ массива.
Определение char а[10]; указывает компилятору на необходимость резервирования места для максимум 10 символов. Константа а содержит адрес ячейки памяти, в которой помещено значение первого из десяти объектов типа char. Процедуры, связанные с занесением конкретной строки в массив а, копируют ее по одному символу в область памяти, на которую указывает константа а, до тех пор, пока не будет скопирован нулевой символ, оканчивающий строку. Когда выполняется функция типа printf("%s", а), ей передается значение а, т.е. адрес первого символа, на который указывает а. Если первый символ - нулевой, то работа функции printf() заканчивается, а если нет, то она выводит его на экран, прибавляет к адресу единицу и снова начинает проверку на нулевой символ. Такая обработка позволяет снять ограничения на длину строки (конечно, в пределах объявленной размерности): строка может иметь любую длину, но в пределах доступной памяти.
Инициализировать строку при таком способе определения можно следующим образом:
char array[7] = "Строка";
char s[ ] = {'С', 'т', 'р', 'о', 'к', 'а', '\0'};
(при определении массива с одновременной инициализацией пределы изменения индекса можно не указывать).
Второй способ определения строки - это использование указателя на символ. Определение char *b; задает переменную b, которая может содержать адрес некоторого объекта. Однако в данном случае компилятор не резервирует место для хранения символов и не инициализирует переменную b конкретным значением. Когда компилятор встречает оператор вида b ="IBM PC";, он производит следующие действия. Во-первых, как и в предыдущем случае, он создает в каком-либо месте объектного модуля строку "IBM PC", за которой следует нулевой символ ('\0'). Во-вторых, он присваивает значение начального адреса этой строки (адрес символа 'I') переменной b. Функция printf("%s", b) работает так же, как и в предыдущем случае, осуществляя вывод символов до тех пор, пока не встретится заключительный нуль.
Массив указателей можно инициализировать, т.е. назначать его элементам конкретные адреса некоторых заданных строк при определении.
Для ввода и вывода строк символов помимо scanf() и printf() могут использоваться функции gets() и puts() (их прототипы находятся в файле stdio.h).
Если string – массив символов, то ввести строку с клавиатуры можно так:
gets(string);
(ввод оканчивается нажатием клавиши <Enter>). Вывести строку на экран можно следующим образом:
puts(string);
Отметим также, что для работы со строками существует специальная библиотека функций, прототипы которых находятся в файле string.h.
Наиболее часто используются функции strcpy(), strcat(), strlen() и strcmp().
srcpy() – используется для копирования строки или ее части в другую строку.
Копирование происходит побайтно, пока не встретится ‘\0’. Возвращает указатель на строку s1.
strcpy(s1, s2); // копирует строку s2 в строку s1
strncpy(s1, s2,n); //копирует первые n символов из строки s2 в строку s1
Помните, что указываемый массив-приемник s1 должен быть достаточного размера, чтобы содержать строку-источник s2, иначе программа может быть испорчена. Если n больше, чем длина строки в s2, то в s1 символы заполняются нулями до величины n.
Задавая аргумент-источник не ссылкой на начало символьного массива, а адресом любого его элемента, мы можем скопировать либо правую, либо среднюю подстроку:
9 strcpy(s1,&s2[k]); //копирует правую подстроку из s2 в s1
9 strncpy(s1,&s[2],n); //копирует среднюю подстроку из s2 в s1
char * strcpy_my (char *s1, char *s2) //Пример функции копирования
{
char *ptrs1 = s1;
while (( *s1++ = *s2++) != 0);
return ptrs1;
}
Обратите внимание, что использование нулевого ограничителя упрощает различные операции над строками.
Длина строк в языке си определяется системной функцией strlen(). Единственным ее аргументом ёявляется анализируемая строка. Функция возвращает длину строки в символах без учета нулевого ограничителя.
void main() /*пример функции*/
{
char str[80];
printf("ввести строку: ");
gets(str);
printf("%d", strlen(s));
}
В Си операция конкатенации (объединения) строк реализуется с помощью функции strcat():
strcat(s1,s2); //добавляет s2 к s1
strncat(s1,s2,n); //добавляет n первых символов из s2 к s1
Поиск вхождения одной строки в другую дает ответ на вопрос, содержится ли значение одного текста в другом и с какой позиции обнаружено это вхождение. Нулевая позиция в качестве результата такой операции соответствует отрицательному ответу.
char * strcat_my (char *s1, char *s2) /*Пример собственной функции конкатенации*/
{
char *p1, *p2;
p1 = s1; p2 = s2;
while ( *p1 != ‘\0’) p1++; //найти конец 1-ой строки.
//или while ( *p1) p1++;
while (( *p1 = *p2) != 0)//копировать строку р2, пока не будет скопирован
{
p1++; // нулевой ограничитель
p2++; //Передвинуть указатели к следующему байту
} //Или while (( *p1++ = *p2++) != 0);/*.
*р1 = ‘\0’;
return s1;
}
Язык Си предлагает довольно разнообразные варианты поиска вхождений:
strstr(s1,s2); //ищет вхождение строки s2 в s1
strchr(s1,c); //ищет вхождение символа ‘с’ с начала строки s1
strrcgr(s1,c); //ищет вхождение символа ‘с’ с конца строки s1
strpbrk(s1,s2); //ищет вхождение любого символа из s2 в s1
strspn(s1,s2); //ищет вхождение любого фрагмента, составленного из
//символов s2 в s1
strcmp() – осуществляет сравнение текстовых данных. Операции сравнения отдельных символов или строк основаны на последовательном анализе отношений числовых значений соответствующих кодов. В кодовых страницах символы букв упорядочены в соответствии их расположением в латинском или национальном алфавитах. Поэтому код буквы "A" меньше кода буквы "F", код буквы "Г" меньше кода буквы "Ю" и т.д.
Некоторое неудобство вызывает тот факт, что одноименные большие и малые буквы имеют разные коды – в одной клетке кодировочной таблицы можно разместить только один символ, кроме того большие и малые буквы имеют разный смысл. Это не позволяет напрямую упорядочить слова в соответствии с их лексикографическим расположением в словарях. Поэтому приходится предварительно заменять коды всех малых букв в тексте на коды больших (или наоборот) и только после этого выполнять операцию сравнения. Такая замена для букв латинского алфавита особых проблем не представляет, т.к. смещение между кодами соответствующих больших и малых букв - величина постоянная. А вот с русскими буквами приходится повозиться – в кодировке ASCII цепочка малых букв между "п" и "р" разорвана символами псевдографики, а буквы "Ё" и "ё" вообще находятся не на своих местах.
Учитывая эту специфику, следует достаточно внимательно использовать языковые средства, связанные с преобразованием или игнорированием разницы в кодировке больших и малых букв. Для русскоязычных текстов их применять нельзя.
Язык Си позволяет преобразовывать содержимое символьных строк к верхнему strupr(s) или к нижнему strlwr(s) регистру. Но коды символов, не принадлежащих множеству букв латинского алфавита, остаются при этом без изменения.
Для сравнения строк Си предлагает довольно много системных функций, но не забывайте, что их действие не всегда допустимо над русскими словами. Каждая из описываемых ниже функций принимает положительное значение, если ее первый операнд строго "больше" (лексикографически) второго, нулевое значение при "равенстве" операндов, и отрицательное значение, если первый операнд оказался "меньше".
strcmp(s1,s2); //сравнивает строки s1 и s2
strcmpi(s1,s2); //сравнивает s1 и s2 с игнорированием разницы между
//большими и малыми буквами
stricmp(s1,s2); //эквивалентна функции strcmpi
strncmp(s1,s2,k); //сравнивает первые k символов в s1 и s2
strncmpi(s1,s2,k); //сравнивает первые k символов в s1 и s2 с
//игнорированием разницы между большими и
//малыми буквами
strnicmp(s1,s2,k); //эквивалентна функции strncmpi
Функцию strcmp() можно использовать для проверки вводимого пароля, как показано в следующем примере:
/* вернуть "верно", если пароль угадан */
password()
{
char s[80];
printf("ввести пароль: ");
gets(s);
if(strcmp(s, "пароль"))
{
printf("пароль ошибочен\n");
return 0;
}
return 1;
}
Имейте в виду, что если строки равны, функция strcmp() возвращает "ложь", и если вы хотите использовать это условия для другого действия, необходимо записывать оператор логического отрицания «!» (NOT), как показано в следующем примере:
main()
{
char s[80];
for('')
{
printf(": ");
gets(s);
if(!strсmp("quit", s)) break;
}
}
Эта программа будет продолжать запрашивать ввод до тех пор, пока не будет введено слово quit. Следующий пример иллюстрирует действие функций обработки строк:
main()
{
char s1[80], s2[80];
gets(s1); gets(s2);
printf("Длина: %c %c\n", strlen(s1), strlen(s2));
if(!strcmp(s1, s2)) printf("Эти строки равны\n");
strcat(s1,s2);
printf("%s\n", s1);
}
Если вы выполните эту программу и введете строки hello и hello, то в результате получите:
Длина: 5 5
Эти строки равны
Hellohello
До сих пор мы рассматривали присваивание указателю адреса только первого элемента массива. Однако это можно делать и с адресом любого отдельного элемента массива путем добавления & к индексированному имени. Особенно удобно пользоваться этим правилом при выделении подстроки.
Например, следующая программа выводит на экран остаток введенной строки после первого пробела:
/* вывести на экран остаток строки после первого пробела */
main()
{
char s[80];
char *p;
int i;
printf("ввести строку: ");
gets(s);
/* найти первый пробел или конец строки */
for(i=0; s[i] && s[i]!=` `; i++);
p = &s[i];
printf(p);
}
В этой программе p будет указывать либо на пробел, если он есть, либо на ноль, если в строке нет пробелов. Если p указывает на пробел, то программа выведет на экран его и затем остаток строки. Например, если вы введете фразу язык программирования Си, функция printf() напечатает сначала пробел и затем программирования Си. Если p укажет на ноль, то ничего не выводится на экран.
Имена переменных и констант строкового типа рекомендуется начинать с символов «s» или «str», например «sMyString», «strName».
Данные комбинированного типа (структуры)
Структура – это объединение одного или нескольких объектов (переменных, массивов, указателей, других структур и т.д.). Как и массив, она представляет собой совокупность данных. Отличием является то, что к ее элементам необходимо обращаться по имени и что различные элементы структуры не обязательно должны принадлежать одному типу.
Объявление структуры осуществляется с помощью ключевого слова struct, за которым идет ее тип и далее список элементов, заключенных в фигурные скобки:
struct тип
{
тип элемента_1 имя элемента_1;
тип элемента_n имя элемента_n;
};
Именем элемента может быть любой идентификатор. Как и выше, в одной строке можно записывать через запятую несколько идентификаторов одного типа.
Рассмотрим пример:
sruct date
{
int day;
int month;
int year;
};
Следом за фигурной скобкой, заканчивающей список элементов, могут записываться переменные данного типа, например:
struct date {...} a, b, c;
(при этом выделяется соответствующая память). Описание без последующего списка не выделяет никакой памяти; оно просто задает форму структуры. Введенное имя типа позже можно использовать для объявления структуры, например:
struct date days;
Теперь переменная days имеет тип date.
При необходимости структуры можно инициализировать, помещая вслед за описанием список начальных значений элементов.
Разрешается вкладывать структуры друг в друга, например:
struct man
{
char name[20], fam[20];
struct date bd;
int age;
};
Определенный выше тип data включает три элемента: day, month, year, содержащий целые значения (int). Структура man включает элементы name, fam, bd и voz. Первые два – name[20] и fam[20] - это символьные массивы из 20 элементов каждый. Переменная bd представлена составным элементом (вложенной структурой) типа data. Элемент age содержит значения целого типа (int). Теперь можно определить переменные, значения которых принадлежат введенному типу:
struct man man_[100];
Здесь определен массив man_, состоящий из 100 структур типа man.
Чтобы обратиться к отдельному элементу структуры, необходимо указать его имя, поставить точку и сразу же за ней записать имя нужного элемента, например:
man_[j].age = 19;
man_[j].bd.day = 24;
man_[j].bd.month = 2
man_[j].bd.year = 1987;
При работе со структурами необходимо помнить, что тип элемента определяется соответствующей строкой описания в фигурных скобках. Например, массив man_ имеет тип man, year является целым числом и т.п. Поскольку каждый элемент структуры относится к определенному типу, его имя может появиться везде, где разрешено использование значений этого типа. Допускаются конструкции вида man_[i]=man_[j]; где man_[i] и man_[j] – объекты, соответствующие единому описанию структуры. Другими словами, разрешается присваивать одну структуру другой по их именам.
Унарная операция & позволяет взять адрес структуры. Предположим, что определена переменная day:
struct date {int d, m, у;} day;
Здесь day – это структура типа date, включающая три элемента: d, m, у. Другое определение
struct date *db;
устанавливает тот факт, что db - это указатель на структуру типа date.
Запишем выражение:
db = &day;
В этом случае для выбора элементов d, m, у структуры необходимо использовать конструкции:
(*db).d; (*db).m; (*db).y;
Действительно, db - это адрес структуры, *db - сама структура. Круглые скобки здесь необходимы, так как точка имеет более высокий, чем звездочка, приоритет. Для аналогичных целей в языке Си предусмотрена специальная операция –>. Эта операция выбирает элемент структуры и позволяет представить рассмотренные выше конструкции в более простом виде:
db -> d; db -> m; db -> у;
Пример 13. Рассмотрим структуру, в которой хранится информация о студенте. Далее в программе мы присваиваем определенным полям нужные значения, в зависимости от значения селектора варианта (Curs).
struct Student
{
char FIO[20];
int YearBirth;
bool sex;
char Group[20];
float Stipendia;
int Curs;
int SchoolNo;
char SchoolCity[7];
int KruzhokNo[5];
char DiplomTema[50];
char MestoPractiki[50];
} Stud1;
switch(Stud1.Curs)
{
case 1 : Stud1.SchoolNo = 345;
Stud1.SchoolCity = "Москва";
break;
case 2 : Stud1.KruzhokNo[1]:=22;
break;
case 5 : Stud1.DiplomTema="Программная система на Си";
Stud1.MestoPractiki="МГУП";
break;
}
Перечисления
В языке Си перечислением (множеством) называется группа элементов, ассоциированных с единым именем. Перечисляемый тип данных реализован в языке Си с целью использования в программах возможностей математической теории конечных множеств. Множество (или перечисление) описывается с помощью конструкции:
enum <имя множества> (элементы множества);
Например:
enum seasons (spring, summer, autumn, winter);
enum seasons а, b, с;
Здесь введен новый тип данных seasons и определены переменные этого типа. Каждая из них (а, b, c) может принимать одно из четырех значений: spring, summer, autumn и winter. Эти переменные можно было определить сразу при описании типа:
enum seasons (spring, summer, autumn, winter) a, b, с;
Рассмотрим еще один пример:
enum days {mon, tues, wed, thur, fri, sat, sun} my_week;
Имена, занесенные в days (также как и в seasons в предыдущем примере), представляют собой константы целого типа. Первая из них (mon) автоматически устанавливается в нуль, и каждая следующая имеет значение на единицу больше, чем предыдущая (tues=1, wed=2 и т.д.).
Можно присвоить константам определенные значения целого типа (именам, не имеющим их, будут, как и раньше, назначены значения предыдущих констант, увеличенные на единицу). Например:
enum days (man=5, tues=8, wed=10, thur, fri, sat, sun} my_week;
После этого mon=5, tues=8,wed=10, thur=11, fri=12, sat=13, sun=14.
Тип enum можно использовать для задания констант true=1 и false=0, например:
enum t_f (false, true) а, b;
Пример 14. Пусть требуется ввести строку, состоящую из латинских букв, цифр, пробелов. Требуется напечатать заданный текст, удалив из него все цифры.
int i;
char z; /*Текущий вводимый символ*/
printf("\nНапишите предложение с точкой в конце:\n");
for(i=0;z!='.';i++)
{
scanf("%c",&z);
if(z=='0'||z=='1'||z=='2'||z=='3'||z=='4')continue;
if(z=='5'||z=='6'||z=='7'||z=='8'||z=='9')continue;
printf("%c",z);
}
Объединения
Обединения – это некоторая переменная, которая может хранить (в разное время) объекты различного типа и размера. В результате появляется возможность работы в одной и той же области памяти с данными различного вида. Для описания объединения используется ключевое слово union, а соответствующий синтаксис аналогичен структурам. Пусть задано определение:
union r
{
int ir;
float fr;
char cr;
} z;
Здесь ir имеет размер 2 байта, fr - 4 байта, cr - 1 байт. Размер переменной z будет равен размеру самого большого из трех приведенных типов (т.е. 4 байтам). В один и тот же момент времени z может иметь значение только одной из переменных ir, fr или cr.
Указатели
Указатель - это адрес памяти, распределяемой для размещения идентификатора (в качестве идентификатора может выступать имя переменной, массива, структуры, строкового литерала). В том случае, если переменная объявлена как указатель, то она содержит адрес памяти, по которому может находиться скалярная величина любого типа. При объявлении переменной типа указатель, необходимо определить тип объекта данных, адрес которых будет содержать переменная, и имя указателя с предшествующей звездочкой (или группой звездочек). Формат объявления указателя:
<спецификатор типа> [< модификатор> ] * описатель.
Спецификатор типа задает тип объекта и может быть любого основного типа, типа структуры, смеси (об этом будет сказано ниже). Задавая вместо спецификатора-типа ключевое слово void, можно своеобразным образом отсрочить спецификацию типа, на который ссылается указатель. Переменная, объявляемая как указатель на тип void, может быть использована для ссылки на объект любого типа. Однако для того, чтобы можно было выполнить арифметические и логические операции над указателями или над объектами, на которые они указывают, необходимо при выполнении каждой операции явно определить тип объектов. Такие определения типов может быть выполнено с помощью операции приведения типов.
В качестве модификаторов при объявлении указателя могут выступать ключевые слова const, near, far, huge. Ключевое слово const указывает, что указатель не может быть изменен в программе. Размер переменной объявленной как указатель, зависит от архитектуры компьютера и от используемой модели памяти, для которой будет компилироваться программа. Указатели на различные типы данных не обязательно должны иметь одинаковую длину.
Для модификации размера указателя можно использовать ключевые слова near, far, huge.
unsigned int * a; /* переменная а представляет собой указатель
на тип unsigned int (целые числа без знака) */
double * x; /* переменная х указывает на тип данных с
плавающей точкой удвоенной точности */
char * fuffer; /* объявляется указатель с именем fuffer
который указывает на переменную типа char */
double nomer;
void *addres;
addres = & nomer;
(double *)addres ++;
/* Переменная addres объявлена как указатель на объект любого типа. Поэтому ей можно присвоить адрес любого объекта (& - операция вычисления адреса). Однако, как было отмечено выше, ни одна арифмитическая операция не может быть выполнена над указателем, пока не будет явно определен тип данных, на которые он указывает. Это можно сделать, используя операцию приведения типа (double *) для преобразования addres к указателю на тип double, а затем увеличение адреса. */
const * dr;
/* Переменная dr объявлена как указатель на константное выражение, т.е. значение указателя может изменяться в процессе выполнения программы, а величина, на которую он указывает, нет. */
unsigned char * const w = &obj.
/* Переменная w объявлена как константный указатель на данные типа char unsigned. Это означает, что на протяжение всей программы w будет указывать на одну и ту же область памяти. Содержание же этой области может быть изменено. */
Методы доступа к массивам
В языке Си между указателями и массивами существует тесная связь. Например, когда объявляется массив в виде int array[25], то этим определяется не только выделение памяти для двадцати пяти элементов массива, но и для указателя с именем array, значение которого равно адресу первого по счету (нулевого) элемента массива, т.е. сам массив остается безымянным, а доступ к элементам массива осуществляется через указатель с именем array. С точки зрения синтаксиса языка указатель arrey является константой, значение которой можно использовать в выражениях, но изменить это значение нельзя.
Поскольку имя массива является указателем допустимо, например, такое присваивание:
int arrey[25];
int *ptr;
ptr = array;
Здесь указатель ptr устанавливается на адрес первого элемента массива, причем присваивание ptr = arrey можно записать в эквивалентной форме ptr = &arrey[0].
Для доступа к элементам массива существует два различных способа. Первый способ связан с использованием обычных индексных выражений в квадратных скобках, например, array[16] = 3 или array[i+2] = 7. При таком способе доступа записываются два выражения, причем второе выражение заключается в квадратные скобки. Одно из этих выражений должно быть указателем, а второе - выражением целого типа. Последовательность записи этих выражений может быть любой, но в квадратных скобках записывается выражение следующее вторым. Поэтому записи array[16] и 16[array] будут эквивалентными и обозначают элемент массива с номером шестнадцать. Указатель, используемый в индексном выражении не обязательно должен быть константой, указывающей на какой-либо массив, это может быть и переменная. В частности после выполнения присваивания ptr = array доступ к шестнадцатому элементу массива можно получить с помощью указателя ptr в форме ptr[16] или 16[ptr].
Второй способ доступа к элементам массива связан с использованием адресных выражений и операции разадресации в форме *(array+16) = 3 или *(array+i+2) = 7. При таком способе доступа адресное выражение равное адресу шестнадцатого элемента массива тоже может быть записано разными способами *(array+16) или *(16+array).
При реализации на компьютере первый способ приводится ко второму, т.е. индексное выражение преобразуется к адресному. Для приведенных примеров array[16] и 16[array] преобразуются в *(array+16).
Для доступа к начальному элементу массива (т.е. к элементу с нулевым индексом) можно использовать просто значение указателя array или ptr. Любое из присваиваний
*array = 2;
array[0] = 2;
*(array+0) = 2;
*ptr = 2;
ptr[0] = 2;
*(ptr+0) = 2;
присваивает начальному элементу массива значение 2, но быстрее всего выполнятся присваивания *array=2 и *ptr=2, так как в них не требуется выполнять операции сложения.