- •1. Краткие теоретические сведения
- •1.1. Понятие указателя
- •1.2. Объявление указателя
- •1.3. Операции над указателями
- •1.4. Передача параметра по ссылке
- •1.5. Динамическое выделение памяти
- •1.5.1. Динамическое размещение одномерного массива
- •1.5.2. Динамическое размещение двухмерного массива
- •1.5.3. Динамические массивы
- •1.5.4. Формирование динамических массивов с использованием библиотечных функций
- •1.5.5. Формирование динамических массивов с использованием операций new и delete
- •1.5.6. Динамические массивы
- •1.5.7. Динамические массивы
- •1.5.8. Динамические массивы
- •1.5.9. Освобождение выделенной динамической памяти.
- •1.5.10. Описание динамической строки
- •1.5.11. Объявление динамического массива
- •1.6. Связь указателей и массивов
- •1.7. Массивы указателей
- •1.8. Массивы и функции
- •1.9. Указатель на символьную строку
- •Второй пример
- •Увеличение указателя на символьную строку
- •Уменьшение количества операторов
- •Сканирование символьной строки
- •1.10. Заполнение массивов случайными числами
- •1.12. Примеры программирования задач
- •2. Задание
- •2.4. Задания для выполнения на занятиях
- •2.4.1. Задание 1. Динамические одномерные массивы
- •2.4.1.1. Варианты заданий
- •2.4.1.2. Пример обработки динамического массива для варианта 30
- •2.4.1.3. Программа
- •Int *a, *b; // указатели исходных одномерных массивов a и b
- •2.4.1.4. Тестирование
- •2.4.2. Задание 2. Динамические двумерных массивы
- •2.4.2.1. Варианты заданий
- •2.4.2.2. Пример для варианта 30
- •2.4.2.3. Программа
- •2.4.2.4. Тестирование
- •2.4.3. Задание 3. Динамические одномерные массивы Викентьева
- •2.4.3.1. Варианты заданий
- •2.4.4.1. Варианты заданий
- •4. Требование к отчету
- •4. Краткие теоретические сведения.
- •5. Вопросы для самоконтроля
- •Литература
- •1. Краткие теоретические сведения 2
- •1.1. Понятие указателя 2
1.6. Связь указателей и массивов
Существует тесная связь между массивами и указателями. Она заключается в том, что в объявленном массиве его имя является указателем на массив, а точнее, на первый элемент массива. Таким образом, если был объявлен массив int t[31]; то t является указателем на массив, а операторы pl=t; и pl=&t[0]; приведут к одному и тому же результату. Для того чтобы получить значение 8-го элемента массива t можно написать t[7] или *(t+7). Результат будет один и тот же. Преимущество второго варианта заключается в том, что арифметические операции над указателями выполняются быстрее, чем действия с элементами массива.
Для большей наглядности использования указателей решим следующий пример без использования указателей и с использованием указателей.
Пример 15.1
Дана последовательность температур t0 ... t30. Организовать массив для хранения этой последовательности. Определить среднемесячную температуру.
Вариант 1. Без использования указателей
#include <iostream.h>
int main(void)
{
float t[31]; //описание массива
int i; //параметр цикла for
float s; //сумма элементов
for (i=0;i<=30;i++) //заполнение массива
{
cout << "введите элемент с номером" << i;
cin >> t[i];
};
s=0; //обнуление суммы
for (i=0;i<=30;i++) s=s+t[i]; //вычисление суммы
cout << "среднемесячная температура" << s/31;
} // конец программы.
Вариант 2. С использованием указателей
#include <iostream.h>
int main(void)
{
float t[31]; //описание массива
int i; //параметр цикла for
float s; //сумма элементов
for (i=0;i<=30;i++) //заполнение массива
{
cout << "введите элемент с номером" << i;
cin >> *(t+i);
};
s=0; //обнуление суммы
for (i=0;i<=30;i++) s=s+*(t+i); //вычисление суммы
cout << "среднемесячная температура" << s/31;
} // конец программы.
В языке C массивы и указатели тесно связаны друг с другом. Например, когда объявляется массив в виде int a[25], то при этом не только выделяется память для 25 элементов массива, но и формируется указатель с именем a, значение которого равно адресу первого по счету (нулевого) элемента массива. Доступ к элементам массива может осуществляться через указатель с именем a. С точки зрения синтаксиса языка указатель a является константой, значение которой можно использовать в выражениях, но изменить это значение нельзя.
Поскольку имя массива является указателем-константой, допустимо, например, такое присваивание:
int a[25];
int *ptr;
ptr=a;
В этом примере в переменную-указатель ptr записывается адрес начала массива a, т. е. адрес первого элемента массива.
Также справедливы следующие соотношения: например, имеется массив a[N], тогда истинными будут следующие сравнения:
a==&a[0];
*a==a[0].
Указатели можно увеличивать или уменьшать на целое число:
ptr=a+1;
Теперь указатель ptr будет указывать на второй элемент массива a, что эквивалентно &a[1].
При увеличении указателя на единицу адрес, который он представляет, увеличивается на размер объекта связанного с ним типа, например:
int a[25];
int *ptr=a;
ptr+=3;
Первоначально указатель ptr указывал на начало массива a. После прибавления к переменной ptr числа 3 значение указателя увеличилось на 3*sizeof(int), а указатель ptr теперь будет указывать на четвертый элемент массива a. Указатель можно индексировать точно так же, как и массив. На самом деле компилятор преобразует индексацию в арифметику указателей, например, ptr[3]=10 представляется как *(ptr+3)=10.
К указателям типа void арифметические операции применять нельзя, так как им не ставится в соответствие размер области памяти.
Таким образом, в языке C для доступа к элементам массива существует два различных способа. Первый способ связан с использованием обычных индексных выражений в квадратных скобках, например, a[7]=3 или a[i+2]=5. При таком способе доступа записываются два выражения, причем второе выражение заключается в квадратные скобки. Первое из этих выражений должно быть указателем, а второе – выражением целого типа. Указатель, используемый в индексном выражении, не обязательно должен быть константой, указывающей на какой-либо массив, это может быть и переменная-указатель. В частности, после выполнения присваивания ptr=a доступ к седьмому элементу массива можно получить как с помощью константы-указателя a в форме a[7], так и переменной-указателя ptr в форме ptr[7].
Второй способ доступа к элементам массива связан с использованием адресных выражений и операции косвенной адресации в форме *(a+3)=10 или *(a+i+2)=5.
При реализации на компьютере первый способ приводится ко второму, т. е. индексное выражение приводится к адресному. Для приведенных примеров обращение к элементу массива a[3] преобразуется в *(a+3).
Для доступа к начальному элементу массива, т. е. к элементу с нулевым индексом, можно использовать просто значение указателя a или ptr, поэтому любое из присваиваний
*a=2;
a[0]=2;
*(a+0)=2;
*ptr=2;
ptr[0]=2;
*(ptr+0)=2;
присваивает начальному элементу массива значение 2.
Многомерные массивы в языке C – это массивы массивов, т. е. массивы, элементами которых, в свою очередь, являются массивы. При объявлении таких массивов в памяти компьютера создается несколько различных объектов. Например, при выполнении объявления двумерного массива int a2[4][3] в программе создается указатель a2, который определяет в памяти местоположение первого элемента массива и, кроме того, является указателем на массив из четырех указателей. Каждый из этих четырех указателей содержит адрес одномерного массива, представляющего собой строку двумерного массива и состоящего из трех элементов типа int, и позволяет обратиться к соответствующей строке массива.
Таким образом, объявление a2[4][3] порождает в программе три разных объекта: указатель с идентификатором a2, безымянный массив из четырех указателей и безымянный массив из двенадцати чисел типа int. Для доступа к безымянным массивам используются адресные выражения с указателем a2. Доступ к элементам массива указателей осуществляется с указанием одного индексного выражения в форме a2[2] или *(a2+2). Для доступа к элементам двумерного массива чисел типа int должны быть использованы два индексных выражения в форме a2[1][2] или эквивалентных ей *(*(a2+1)+2) и (*(a2+1))[2]. Следует учитывать, что с точки зрения синтаксиса языка C указатель a2 и указатели a2[0], a2[1], a2[2], a2[3] являются константами, и их значения нельзя изменять во время выполнения программы.
Размещение трехмерного массива происходит аналогично. Так, например, объявление float a3[3][4][5] порождает в программе, кроме самого трехмерного массива из 60 чисел типа float, массив из четырех указателей на тип float, массив из трех указателей на массив указателей на float и указатель на массив массивов указателей на float.
При размещении элементов многомерных массивов они располагаются в памяти подряд по строкам, т. е. быстрее всего изменяется последний индекс, а медленнее – первый. Такой порядок дает возможность обращаться к любому элементу многомерного массива, используя адрес его начального элемента и только одно индексное выражение.
Например, обращение к элементу a2[1][2] можно осуществить при помощи указателя ptr2, объявленного в форме int *ptr2=a2[0], как обращение ptr2[1×3+2] (здесь 1 и 2 – это индексы используемого элемента, а 3 – число элементов в строке) или как ptr2[5]. Заметим, что внешне похожее обращение a2[6] выполнить невозможно, так как указателя с индексом 6 не существует.
Для обращения к элементу a3[2][3][4] из трехмерного массива тоже можно использовать указатель, описанный как float *ptr3=a3[0][0], с одним индексным выражением в форме ptr3[2×20+3×5+4] или ptr3[59].
Указатели и массивы тесно связаны между собой. Идентификатор массива является указателем на его первый элемент, т.е. для массива int a[10], выражения a и a[0] имеют одинаковые значения, т.к. адрес первого (с индексом 0) элемента массива – это адрес начала размещения его элементов в ОП.
Пусть объявлены – массив из 10 элементов и указатель типа double:
double a[10], *p;
если p = a; (установить указатель p на начало массива a), то следующие обращения: a[i] , *(a+i) и *(p+i) эквивалентны, т.е. для любых указателей можно использовать две эквивалентные формы доступа к элементам массива: a[i] и *(a+i). Очевидна эквивалентность следующих выражений:
&a[0] « &(*p) « p
Несмотря на то что указатели широко используются с символьными строками, вы можете использовать указатели с массивами других типов. Например, следующая программа использует указатель на массив типа float для вывода значений с плавающей точкой:
#include <iostream.h>
void show_float(float *array, int number_of_elements)
{
int i;
for (i = 0; i < number_of_elements; i++) cout << *array++ << endl;
}
void main(void)
{
float values[5] = {1.1, 2.2, 3.3, 4.4, 5.5);
show_float(values, 5);
}
Как видите, внутри функции show_float цикл for использует значение, указываемое с помощью указателя array, а затем увеличивает этот указатель до следующего значения. В данном случае программа должна передать параметр, который задает количество элементов массива, поскольку в отличие от символьных строк массивы типа float (или int, long и т. д.) не используют символ NULL для определения последнего элемента.
Как вы уже знаете, ваши программы могут использовать указатели на массивы любых типов. В предыдущей программе функция show_float увеличивала указатель для продвижения по массиву типа float. Указатель указывает на участок памяти, содержащий значение определенного типа, например char, int или float. Когда функция сканирует массив с помощью указателя, функция увеличивает указатель для продвижения от одного значения к следующему. Чтобы указатель указывал на следующий элемент массива, C++ должен знать размер каждого элемента (в байтах), чтобы определить, на сколько необходимо увеличить значение указателя. Например, для продвижения указателя к следующему символу в массиве, C++ должен увеличить значение указателя на 1. Однако, чтобы указать следующее значение в массиве типа int C++ должен увеличить указатель на два байта (значение типа int занимает два байта памяти). Для значений типа. float C++ увеличивает указатель на 4 байта. Зная тип значения, на которое указывает указатель, C++ знает, на сколько необходимо увеличить значение этого указателя. В ваших программах вы просто используете оператор увеличения, например pointer++. Однако за кулисами C++ увеличивает реальное значение (адрес памяти), содержащееся в указателе, на корректную величину.