Метод_материалы / Учебники / Программирование_С

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

Приведем фрагмент программы, реализующей этот алгоритм: int j;

int k = 2; // новый элемент добавим на место второго элемента int new_el = 99; // новый элемент new_el

…

for (j = n; j >= k–1; j– –) a[j] =a[j–1];

// после того, как место подготовлено, запишем новый элемент a [k]=new_el;

n++;

1.3.3.Многомерные массивы

Всинтаксисе C определены только одномерные массивы. Массивы большей размерности трактуются как массивы массивов. Все особенности использования статических многомерных массивов можно рассмотреть на примере двумерных массивов (матриц).

1.3.3.1.Описание двумерного массива, размещение в памяти, операции

Описание двумерного массива требует, чтобы были указаны два размера:

число строк и число столбцов матрицы, например:

int a [2][5]; // массив из 2-х одномерных массивов, по 5 элементов //в каждом

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

Пример инициализации двумерных массивов: int a [3] [4] = {

};

При размещении в памяти будет выделено место под запись 3 4 = 12 элементов, и они будут размещены линейно, как на рис. 1.7, в следующем порядке:

Операции над двумерным массивом не разрешены, кроме операции доступа к его элементам (разыменования). Если реальный размер (по описанию) обозначить переменными n, m (матрица имеет n строк и m столбцов) то обращение к

элементу массива aij можно выполнить по индексу (прямая адресация) или указателю (косвенная адресация):

71

for (i = 0; i<n; i ++)

{

// в теле цикла обращение к переменной a[i][j]

}

Зная, что матрица хранится как одномерный массив, можно ее описать как одномерный массив, а элементы адресовать как элементы матрицы, используя косвенную адресацию, например:

int n, m; n = 5; m = 5;

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

for (i = 0; i<n; i ++) for(j = 0; j<m; j ++)

{

// в теле цикла обращение к переменной * (a+i * m + j)

}

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

1.3.3.3. Использование функций при работе с двумерными массивами

Использование функций при обработке матриц предполагает два кардинально различных подхода. В первом случае матрица существует или рассматривается как самостоятельная структура данных, к которой необходимо применить какойлибо алгоритм обработки. В качестве параметра такой функции будет использована вся матрица целиком. Чтобы задача обработки решалась бы в общем виде, в функцию следует передать имя матрицы и ее размеры (как параметры функции), при этом функция получает матрицу как двумерный массив. С должен знать, каков способ разбиения этой структуры на строки, поэтому число строк данных можно опустить, а число данных в каждой строке опускать нельзя. Оно должно быть указано обязательно как константное выражение в квадратных скобках при передаче матрицы. Так, прототип функции, получающей матрицу в качестве входного данного, может выглядеть так:

int function (int a [][m], int n, int m); // здесь m – константное выражение

В качестве примера рассмотрим функции для ввода и вывода матрицы на экран. Предполагается, что матрица условно переменного размера, поэтому число строк и столбцов матрицы по описанию определено define-константами N = 5 и M = 5. Реальный размер матрицы определяют переменные n, m, значения которых вводятся.

73

void input_matr (int a[][M], int &n, int &m); // важно, что длина строки —это

// константа

void print_matr (int a[][M], int n, int m); // число строк можно не передавать

// главная программа описывает входные данные

// описание функции ввода. Параметры функции — имя и размеры массива void input_matr (int a[][M], int &n, int &m) // n, m возвращаются по ссылке

{

int i, j;

printf ("Введите размер матрицы не более %d на %d\n", N, M); scanf ("%d%d", &n, &m);

printf ("Введите матрицу.\n"); for (i = 0;i < n; i ++)

for (j = 0; j < m; j ++) scanf("%d", &matr[i][j]);

}

// описание функции вывода. Параметры функции — имя и размеры массива void print_matr (int a[][M], int n, int m)

{

int i, j;

for (i = 0; i < n; i ++)

{

for (j = 0; j<m; j++)

printf ("%5d", mas[i][j]);

}

Во втором случае матрица рассматривается как массив из одномерных массивов, при этом для обработки отдельных строк матрицы можно использовать функции обработки одномерных массивов. Зная, что элементы матрицы — это

74

одномерные массивы, каждый из них можно по очереди передавать в функцию, которая работает с одномерным массивом.

1.3.4. Указатели

Любой объект программы (переменная, массив, функция и прочие) имеет необходимые атрибуты и операции:

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

операции: взять значение по указанному адресу или изменить значение.

Если говорить о механизмах программной реализации объекта, то имя, это адрес области памяти, а значение, это содержимое области памяти.

Определение. Указатели — такие объекты (переменные), значением которых являются адреса других объектов (или какой либо области памяти).

Кроме того, значением указателя может быть пустое значение, не равное никакому адресу — NULL.

1.3.4.1. Объявление указателей

Описание переменных типа указатель обязательно должно показывать тип переменной, которую адресует указатель. Сама переменная типа указатель имеет всегда одинаковый размер 2 или 4 байта в зависимости от модели памяти.

Признаком того, что в объявлении вводится указатель, является символ '*'.

Рисунок 1.8. Размещение переменных и указателей в памяти.

Пусть объявлены указатели:

75

Тогда размещение переменных и указателей в памяти будет таким, как на рис. 1.8.

1.3.4.2. Операции над указателями

Операция получения адреса &

Это унарная операция, которая может быть применена к операнду любого типа. Возвращает 16-ричный адрес объекта (его размещение в памяти).

//операция &x получит адрес переменной х. Его можно присвоить

//переменной специально предназначенной для хранения адреса, это px.

px = &x; // адрес можно присвоить указателю

Операция применяется только к именованным объектам, размещенным в памяти. Бессмысленно ее применение к константам, выражениям, внешним объектам.

Операция получения значения по указанному адресу «*»

Синонимы — операция разыменования, раскрытия ссылки или обращения по адресу. Это унарная операция, операндом может быть только указатель. Возвращаемое значение имеет тип той переменной, на которую показывает указатель, и возвращает значение, размещенное в той области памяти, на которую ссылается указатель.

Тип данного void может адресовать объект любого типа, но к нему нельзя применить операцию *.

Примеры недопустимого использования void.

p_k = &k; p_y = &y;

76

Операция присваивания для указателей

Операция присваивания в С имеет особенности, связанные с преобразованием типов. Переменной можно присваивать значение выражения такого же типа, как и переменная, но если переменная и выражение разных типов, то выполняется неявное преобразование при присваивании, которое может привести к потере данных. Чтобы избежать неприятностей, рекомендуется использовать явное преобразование типов.

имя_переменной = (имя_типа) имя_переменной; Например:

int x; float y; y = (int) x;

x = (float) y;

При присваивании указателей возможные ошибки несоответствия типов могут вызвать не только потерю данных, но и привести к трагическим последствиям. Представьте, что происходит, если адрес перепутал почтальон. Тем не менее, преобразование типов указателей может быть выполнено точно так же, как и простых типов, но с использованием операции *, например:

int *x; float *y;

y = (int *) x; x = (float *) y;

Механизмы, связанные с таким преобразованием, очень тонкие. Попытаемся показать это на примере.

//объявим переменную L типа unsigned long и запишем в нее

//шестнадцатеричную long константу 0x12345678L

//объявим три указателя (на char, int и long), и

//каждому из них присвоим адрес этой константы (&L)

//при присваивании будем

//выполнять приведение типов (например, *c = (char *) &L)

Унарные операции ++ и – –

Унарные операции ++ и – – изменяют значение адреса в зависимости от типа данных, с которым связан указатель, а именно:

для char на 1 байт,

77

для int на 2 байта, для float на 4 байта.

Эта операция называется смещение указателя. В следующем примере показано, что выделение адресов в сегменте данных происходит не справа налево, а от старших байт вниз.

//операция смещения указателя приведет к просмотру объектов a, b,c ,

//если использовать pa – – или pc++

for( int k = 1; k <= 3; k++)

printf ("\nАдрес %p Значение %d",pa – –, *pa);

// будет выведено то же, что и в трех предыдущих операторах вывода

Сложение и вычитание

Складывать адреса бессмысленно, но можно прибавить к адресу целое число, например, pa + число. Будет получено новое значение адреса, смещенное относительно старого указателя в зависимости от типа указателя, на «число*sizeof (тип_указателя)» в байтах.

Вычитание адресов можно применить к указателю и числу или к двум указателям. В первом случае будет получено новое значение адреса, смещенное относительно старого указателя, как и при сложении. Во втором случае разность (со знаком), это расстояние в единицах, кратных размеру одного объекта указанного типа. Например, смещение pb на +1 — это адрес a, смещение pb на1 — это адрес c.

Пример:

printf ("\nАдрес %p Значение %d", pb+1,*(pb+1)); .........// значение 10

Операции отношения

Все операции отношения могут использоваться для сравнения значений адресов. Разрешается сравнивать только указатели одинакового типа или указатель сравнить с константой NULL. Многие функции стандартных библиотек С, возвращающие указатели. Если функция не может вернуть адрес, то возвращаемым значением будет NULL.

Приоритеты операций, разрешенных над указателями:

•унарные операции косвенной адресации * и получения адреса &,

•аддитивные операции,

•операции сравнения,

•операция присваивания.

78

Операции ++ и – – имеют различный приоритет, наивысший в префиксной форме, например pa++, и наименьший в постфиксной, например pс– –.

1.3.4.3. Указатели и массивы

Синтаксис языка С определяет имя массива как адрес его первого элемента (с нулевым значением индекса). Все следующие элементы располагаются подряд в порядке возрастания адресов. Обращение к элементам массива может быть выполнено с помощью операции [ ] (прямая адресация) или с помощью операции

*(косвенная адресация).

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

Во втором случае для определения номера элемента внутри массива используется смещение указателя от первого элемента.

Например, если объявлен массив: int mas [] = {10, 20, 30, 40};

то mas — это адрес первого элемента массива (адрес mas[0]).

Адрес следующего элемента mas[1] или mas + 1, следующего mas[2] или mas + 2, и так далее.

Косвенная адресация в массивах. Пусть объявлен массив

int mas[] = {10, 20, 30, 40};

Пусть его длина определена: int n = sizeof(mas) / sizeof(int);

Для прямой адресации в массиве используется рабочая переменная, которая определяет целочисленное значение индекса элемента массива:

int i;

...

for ( i = 0 ; i < n; i++) // обращение к mas[i]

Для косвенной адресации в массиве используется рабочая переменная, которая определяет значение адреса элемента массива:

int *pti; // тип этого указателя, как у элементов массива (синоним массива)

...

for ( pti = mas; pti < mas + n; pti++) //обращение к *pti

Обращение к элементам массива при изменении индекса и обращение к элементам массива при смещении указателя показано на рис. 1.9.

int i; int *pti;

pti = mas;

После присваивания pti = mas, указателю доступен адрес массива:

79

printf ("\n Последний элемент массива= %d", *(pti+3));

Выделение памяти для массива mas:

Выделение памяти для указателя pti:

Рисунок 1.9. Прямая и косвенная адресация в массивах

Приведем пример различной адресации в массиве при вычислении суммы элементов массива. Это обычный алгоритм обработки массива. Для решения задачи необходим последовательный просмотр всех элементов массива.

#define N 5 void main(void)

{

int mas [N] = {1, 2, 3, 4, 5}; int Sum;

int i;

//прямая адресация. Обращение к элементам массива через операцию [] for (i = 0, Sum = 0; i < N; i++)

Sum += mas[i];

printf ("\nСумма %d", Sum);

//косвенная адресация. Обращение к элементам массива через операцию * int * pti;

for (pti = mas, Sum = 0; pti < mas + N; pti++) Sum += *pti;

printf("\nСумма %d", Sum);

//косвенная адресация. Обращение к элементам массива смещением указателя

//относительно начала массива

for (pti = mas, i = 0, Sum = 0; i < N; i++) Sum += *(mas + i);

printf("\nСумма %d", Sum);

80