Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
СиАОД_Тычинина.docx
Скачиваний:
1
Добавлен:
01.07.2025
Размер:
2 Мб
Скачать
☆
  1. Варианты задания

Вариант

Задание

1

2

3

4

5

6

7

8

9

10

  1. Написать программу в соответствие с номером варианта (таблица 2.2), вычисляющую значение функции вещественного аргумента х с заданной точностью eps с помощью разложения в бесконечный ряд. Вычисление заканчивается, когда абсолютная величина очередного члена ряда, прибавляемого к сумме, станет меньше заданной точности.

Таблица 2.2

  1. Варианты задания

Вариант

Задание

1

2

.

3

4

5

6

7

8

9

10

Контрольные вопросы

  1. Какие базовые конструкции структурного программирования вы знаете?

  2. Какие операторы ветвления реализованы в языке С++?

  3. Какие операторы цикла реализованы в языке С++?

  4. Как работает оператор switch?

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

  6. Какой синтаксис у оператора for в языке С++?

  7. Какие операторы передачи управления вы знаете?

Лабораторная работа №3 Одномерные массивы и указатели

Цель работы

Приобретение навыков работы с одномерными массивами и указателями.

Теоретическая часть [3]

При использовании простых переменных каждой области памяти для хранения данных соответствует свое имя. Если с группой величин одинакового типа требуется выполнять однообразные действия, им дают одно имя, а различают по порядковому номеру. Это позволяет компактно записывать множество операций с помощью циклов. Конечная именованная последовательность однотипных величин называется массивом. Описание массива в программе отличается от описания простой переменной наличием после имени квадратных скобок, в которых задается количество элементов массива (размерность):

float а [10]; // описание массива из 10 вещественных чисел

Элементы массива нумеруются с нуля. При описании массива используются те же модификаторы (класс памяти, const и инициализатор), что и для простых переменных. Инициализирующие значения для массивов записываются в фигурных скобках. Значения элементам присваиваются по порядку. Если элементов в массиве больше, чем инициализаторов, элементы, для которых значения не указаны, обнуляются:

int b[5] = {3, 2, 1}; / / b[0]=3, b[l]=2, b[2]=l, b[3]=0, b[4]=0.

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

Для доступа к элементу массива после его имени указывается номер элемента (индекс) в квадратных скобках. В следующем примере подсчитывается сумма элементов массива.

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

const int n = 10;

int i, sum;

int marks[n] = {3, 4, 5, 4, 4};

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

sum += marks[i];

cout<<"сумма: "<<sum<<endl;

return 0;

system("pause");

}

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

К массивам удобно обращаться через указатели.

Когда компилятор обрабатывает оператор определения переменной, например, int i=10, он выделяет память в соответствии с типом (int) и инициализирует ее указанным значением (10). Все обращения в программе к переменной по ее имени (i) заменяются компилятором на адрес области памяти, в которой хранится значение переменной. Программист может определить собственные переменные для хранения адресов областей памяти. Такие переменные называются указателями. Итак, указатели предназначены для хранения адресов областей памяти. В C++ различают три вида указателей – указатели на объект, на функцию и на void, отличающиеся свойствами и набором допустимых операций. Указатель не является самостоятельным типом, он всегда связан с каким-либо другим конкретным типом.

Указатель на функцию содержит адрес в сегменте кода, по которому располагается исполняемый код функции, то есть адрес, по которому передается управление при вызове функции. Указатели на функции используются для косвенного вызова функции (не через ее имя, а через обращение к переменной, хранящей ее адрес), а также для передачи имени функции в другую функцию в качестве параметра. Указатель функции имеет тип «указатель функции, возвращающей значение заданного типа и имеющей аргументы заданного типа»:

тип (*имя) (список_типов_аргументов);

Например, объявление:

int (*fun) (double, double);

задает указатель с именем fun на функцию, возвращающую значение типа int и имеющую два аргумента типа double.

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

тип *имя;

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

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

int *a, b, *с;

описываются два указателя на целое с именами а и с, а также целая переменная b.

Размер указателя зависит от модели памяти. Можно определить указатель на указатель и т. д. Указатель на void применяется в тех случаях, когда конкретный тип объекта, адрес которого требуется хранить, не определен (например, если в одной и той же переменной в разные моменты времени требуется хранить адреса объектов различных типов).

Указателю на void можно присвоить значение указателя любого типа, а также сравнивать его с любыми указателями, но перед выполнением каких-либо действий с областью памяти, на которую он ссылается, требуется преобразовать его к конкретному типу явным образом.

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

Инициализатор записывается после имени указателя либо в круглых скобках, либо после знака равенства.

Существуют следующие способы инициализации указателя:

1. Присваивание указателю адреса существующего объекта:

• с помощью операции получения адреса:

int а = 5; // целая переменная

int *р = &а; //в указатель записывается адрес а

int *р (&а); // то же самое другим способом

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

int *r = р;

• с помощью имени массива или функции, которые трактуются как адрес:

int b[10]; // массив

int *t = b; // присваивание адреса начала массива

…

void f (int а){ /* ... * / } // определение функции

void ( *pf ) ( int ); // указатель на функцию

pf = f; // присваивание адреса функции

2. Присваивание указателю адреса области памяти в явном виде:

char *vp = (char *)0хВ8000000

Здесь 0хВ8000000 – шестнадцатеричная константа, (char *) – операция приведения типа: константа преобразуется к типу «указатель на char».

3. Присваивание пустого значения:

int *suxx = NULL;

int *rulez = 0.

В первой строке используется константа NULL, определенная в некоторых заголовочных файлах С как указатель, равный нулю. Рекомендуется использовать просто 0, так как это значение типа int будет правильно преобразовано стандартными способами в соответствии с контекстом. Поскольку гарантируется, что объектов с нулевым адресом нет, пустой указатель можно использовать для проверки, ссылается указатель на конкретный объект или нет.

4. Выделение участка динамической памяти и присваивание ее адреса указателю:

• с помощью операции new:

int *n= new int; //1

int *m = new int(10); // 2

int *q = new int[10]; // 3

• с помощью функции malloc:

int *u = (int *)malloc(sizeof(int)); // 4

В операторе 1 операция new выполняет выделение достаточного для размещения величины типа int участка динамической памяти и записывает адрес начала этого участка в переменную n. Память под саму переменную n (размера, достаточного для размещения указателя) выделяется на этапе компиляции.

В операторе 2, кроме описанных выше действий, производится инициализация выделенной динамической памяти значением 10.

В операторе 3 операция new выполняет выделение памяти под 10 величин типа int (массива из 10 элементов) и записывает адрес начала этого участка в переменную q, которая может трактоваться как имя массива. Через имя можно обращаться к любому элементу массива.

Если память выделить не удалось, по стандарту должно порождаться исключение bad_alloc. Старые версии компиляторов могут возвращать 0. В операторе 4 делается то же самое, что и в операторе 1, но с помощью функции выделения памяти mallос, унаследованной из библиотеки С. В функцию передается один параметр – количество выделяемой памяти в байтах. Конструкция (int*) используется для приведения типа указателя, возвращаемого функцией, к требуемому типу. Если память выделить не удалось, функция возвращает 0. Операцию new использовать предпочтительнее, чем функцию mallос, особенно при работе с объектами.

Освобождение памяти, выделенной с помощью операции new, должно выполняться с помощью delete, а памяти, выделенной функцией mallос – посредством функции free. При этом переменная-указатель сохраняется и может инициализироваться повторно. Приведенные выше динамические переменные уничтожаются следующим образом:

delete n; delete m; delete [ ] q; free (u);

Если память выделялась с помощью new[], для освобождения памяти необходимо применять delete[]. Размерность массива при этом не указывается. Если квадратных скобок нет, то никакого сообщения об ошибке не выдается, но помечен как свободный будет только первый элемент массива, а остальные окажутся недоступны для дальнейших операций. Такие ячейки памяти называются мусором.

Следующий пример копирует все элементы массива a в массив b, используя указатели:

#include <iostream>

using namespace std;

int main(){

const int n=5;

int а[n], b[n];

int i;

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

cin>>а[i];

int *pa=а; // или int *р = &а[0];

int *pb=b;

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

pb[i]=pa[i];// или *pb++=*pa++;

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

cout<<b[i]<<" ";

return 0;

system("pause");

}

Динамические массивы создают с помощью операции new, при этом необходимо указать тип и размерность, например:

int n = 100;

float *р=new float [n];

В этой строке создается переменная-указатель на float, в динамической памяти отводится непрерывная область, достаточная для размещения 100 элементов вещественного типа, и адрес ее начала записывается в указатель р. Динамические массивы нельзя при создании инициализировать, и они не обнуляются. Преимущество динамических массивов состоит в том, что размерность может быть переменной, то есть объем памяти, выделяемой под массив, определяется на этапе выполнения программы. Доступ к элементам динамического массива осуществляется точно так же, как к статическим, например, к элементу номер 5 приведенного выше массива можно обратиться как р[5] или *(р+5).

Альтернативный способ создания динамического массива – использование функции mallос библиотеки С:

int n = 100;

float *q = (float *) malloc(n * sizeof(float));

Операция преобразования типа, записанная перед обращением к функции mal1ос, требуется потому, что функция возвращает значение указателя типа void*, а инициализируется указатель на float.

Память, зарезервированная под динамический массив с помощью new [], должна освобождаться оператором delete [], а память, выделенная функцией mallос – посредством функции free, например:

delete [ ] р; free (q);

При несоответствии способов выделения и освобождения памяти результат не определен. Размерность массива в операции delete не указывается, но квадратные скобки обязательны.

Задача 3.1. Написать программу, которая для целочисленного массива из 10 элементов определяет, сколько положительных элементов располагается между его максимальным и минимальным элементами.

Краткий алгоритм:

  1. Определить, где в массиве максимальный и минимальный элементы и их индексы.

  2. Проверить все элементы между ними. Если элемент массива больше нуля, то увеличить счетчик.

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

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

const int n=10;

int a[n];

int i, imax, imin, count;

cout<<"введите "<<n<<" целых чисел: "<<endl;

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

cin>>a[i];

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

cout<<a[i]<<" ";

for (i=imax=imin=0; i<n; i++) {

if (a[i]>a[imax]) imax=i;

if (a[i]<a[imin]) imin=i;

}

cout<<"\n max= "<<a[imax]<<", min= "<<a[imin];

int ibeg=imax<imin?imax:imin;

int iend=imax<imin?imin:imax;

cout<<"\n ibeg= "<<ibeg<<", iend= "<<iend;

for (count=0, i=ibeg+1; i<iend; i++)

if (a[i]>0) count++;

cout<<"\n кол-во положительных элем-в: "<<count<<endl;

system("pause");

return 0;

}

Задача 3.2. Изменить алгоритм решения предыдущей задачи так, чтобы массив просматривался всегда от максимума к минимуму, а индекс при просмотре увеличивался или уменьшался в зависимости от их расположения.

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

const int n=10;

int a[n];

int i, imax, imin, kol;

cout<<"введите "<<n<<" целых: "<<endl;

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

cin>>a[i];

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

cout<<a[i]<<" ";

for (i=imax=imin=0; i<n; i++) {

if (a[i]>a[imax]) imax=i;

if (a[i]<a[imin]) imin=i;

}

int d=0;

if (imax<imin) d=1;

else if (imax>imin) d=-1;

for (kol=0, i=imax+d; i!=imin; i+=d)

if (a[i]>0)

kol++;

cout<<"\n кол-во положительных элем-в: " <<kol<<endl;

system("pause");

return 0;

}

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

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

const int n=100;

int a[n];

int i, kol_a;

cout<<"введите количество элементов: "<<endl;

cin>>kol_a;

if (kol_a>n) {

cout<<" превышение размера массива "<<endl;

return 1;}

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

cin>>a[i];

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

cout<<a[i]<<" ";

cout<<endl;

system("pause");

return 0;

}

Задача 3.3. Написать программу, которая для вещественного массива из n элементов определяет сумму его элементов, расположенных правее последнего отрицательного элемента.

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

int n;

cout<<"введите количество элементов: "<<endl;

cin>>n;

int i, ineg;

float sum, *a=new float [n];

cout<<"введите элементы массива "<<endl;

for (i=0; i<n; i++) cin>>a[i];

for (i=0; i<n; i++) cout<<a[i]<<" ";

for (i=0; i<n; i++) if (a[i]<0) ineg=i;

for (sum=0, i=ineg+1; i<n; i++) sum+=a[i];

cout<<"\n сумма "<<sum<<endl;

system("pause");

return 0;

}

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

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

int n;

cout<<"введите количество элементов: "<<endl;

cin>>n;

int i;

float sum, *a=new float [n];

cout<<"введите элементы массива "<<endl;

for (i=0; i<n; i++) cin>>a[i];

for (i=0; i<n; i++) cout<<a[i]<<" ";

int ineg=-1;

for (i=0; i<n; i++) if (a[i]<0) ineg=i;

if (ineg!=-1) {

for (sum=0, i=ineg+1; i<n; i++) sum+=a[i];

cout<<"\n сумма "<<sum<<endl; }

else cout<<"\n отрицательных элементов нет"<<endl;

system("pause");

return 0;

}

Можно просматривать массив и в обратном порядке, суммируя его элементы до тех пор, пока не встретится отрицательный.

#include <iostream>

using namespace std;

int main(){

setlocale(LC_CTYPE,"RUS");

int n;

cout<<" введите количество элементов: "<<endl;

cin>>n;

int i;

float *a=new float [n];

cout<<" введите элементы массива "<<endl;

for (i=0; i<n; i++) cin>>a[i];

for (i=0; i<n; i++) cout<<a[i]<<" ";

bool flag_neg=false;

float sum=0;

for (i=n-1; i>=0; i--) {if (a[i]<0) {flag_neg=true; break;}

sum+=a[i];}

if (flag_neg) cout<<"\n сумма "<<sum<<endl;

else cout<<"\n отрицательных элементов нет "<<endl;

system("pause");

return 0;

}

Порядок выполнения работы

  1. Ознакомьтесь с теоретическим материалом и в соответствии с ним создайте новый проект.

  2. Разберите все задачи теоретической части и проверьте их работоспособность в Visual C++.

  3. Сделайте задание для самостоятельного выполнения в соответствии с номером варианта.

  4. Напишите отчет в соответствии с требованиями, приведенными на стр. 20.

  5. Потренируйтесь отвечать на контрольные вопросы.

Задание для самостоятельного выполнения

При написании программ можно использовать как динамические, так и не динамические массивы. Размерность последних задается именованной константой.

Вариант 1

В одномерном массиве, состоящем из n вещественных элементов вычислить:

  • Сумму отрицательных элементов массива.

  • Произведение элементов массива, расположенных между максимальным и минимальным элементами массива.

Вариант 2

В одномерном массиве, состоящем из n вещественных элементов,

вычислить:

  • Сумму положительных элементов массива.

  • Произведение элементов массива, расположенных между максимальным по модулю и минимальным по модулю элементами массива.

Вариант 3

В одномерном массиве, состоящем из n целых элементов вычислить:

  • Произведение элементов массива с четными номерами.

  • Сумму элементов массива, расположенных между первым и последним нулевыми элементами.

Вариант 4

В одномерном массиве, состоящем из n вещественных элементов вычислить:

  • Сумму элементов массива с нечетными номерами.

  • Сумму элементов массива, расположенных между первым и последним отрицательными элементами.

Вариант 5

В одномерном массиве, состоящем из n вещественных элементов вычислить:

  • Максимальный элемент массива.

  • Сумму элементов массива, расположенных до последнего положительного элемента.

Вариант 6

В одномерном массиве, состоящем из n вещественных элементов вычислить:

  • Минимальный элемент массива.

  • Сумму элементов массива, расположенных между первым и последним положительными элементами..

Вариант 7

В одномерном массиве, состоящем из n целых элементов вычислить:

  • Номер максимального элемента массива.

  • Произведение элементов массива, расположенных между первым и вторым нулевыми элементами.

Вариант 8

В одномерном массиве, состоящем из n вещественных элементов вычислить:

  • Номер минимального элемента массива.

  • Сумму элементов массива, расположенных между первым и вторым отрицательными элементами.

Вариант 9

В одномерном массиве, состоящем из n вещественных элементов вычислить:

  • Максимальный по модулю элемент массива.

  • Сумму элементов массива, расположенных между первым и вторым положительными элементами.

Вариант 10

В одномерном массиве, состоящем из n целых элементов вычислить:

  • Минимальный по модулю элемент массива.

  • Сумму модулей элементов массива, расположенных после первого элемента равного нулю.