20) Оператор break. Оператор continue. Совместное использование операторов break и continue. Оператор break

Оператор break обеспечивает прекращение выполнения самого внутреннего из объединяющих его операторов switch, do, for, while. После выполнения оператора break управление передается оператору, следующему за прерванным

#include<iostream.h>

int main()

{ int i,p=0;

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

{ p=p+1;

if (p==2) break; }

cout<<p<<endl;

return 0; }На экран выведется 2

Оператор continue

Оператор continue, как и оператор break, используется только внутри операторов цикла, но в отличие от него выполнение программы продолжается не с оператора, следующего за прерванным оператором, а с начала прерванного оператора. Формат оператора следующий:

continue;

Пример:

int main()

{ int a,b;

for (a=1,b=0; a<100; b+=a,a++)

{ if (b%2) continue; /* обработка четных сумм */ } return 0; }

Когда сумма чисел от 1 до а становится нечетной, оператор continue передает управление на очередную итерацию цикла for, не выполняя операторы обработки четных сумм.

Оператор continue, как и оператор break, прерывает самый внутренний из объемлющих его циклов.

22) Операторы динамического распределения памяти (new, delete).

Выделение памяти с помощью оператора new имеет следующий синтаксис: указатель = new тип; указатель = new тип [число элементов]; Вторая строка описывает синтаксис оператора при выделении памяти для массивов. оператор new возвращает значение NULL, если объем требуемой памяти больше, чем объем свободной. Рекомендуется проверить факт выделения памяти прежде, чем продолжать выполнение программы. Освобождение памяти с помощью оператора delete производится только в том случае, если она была выделена с использованием оператора new и имеет следующий синтаксис: delete указатель; delete [число элементов] указатель; Использование квадратных скобок для освобождения памяти, выделенной под массив, обязательно. Как и при инициализации, его длину можно опустить, но скобки опускать нельзя, иначе освободится память, занимаемая только первым элементом. Указатель на константу удалить нельзя. Рассмотрим программу, ввода/вывода одномерного массива: int n; float *massiv;      //объявление указателя cout<<"Введите размер массива"<<endl;

cin>>n;//ввод размера массива massiv=new float[n];//динамическое выделение памяти if(!massiv)                              //проверка факта выделения памяти {cout<<"Недостаточно памяти"<<endl;  } cout<<"Введите элементы massiv"<<endl; for(int i=0;i<n;i++) cin>>*(massiv+i); //вывод массива cout<<"massiv"<<endl; for( i=0;i<n;i++) cout<<"    "<<*(massiv+i); delete [] massiv; //освобождение памяти   В этой программе указатель используется для выделения динамической памяти и доступа к элементам массива.

24) Определение переменных указателей . Инициализация указателей.

Указатель – это « всего лишь» переменная, значением которой является адрес. То есть это именно такая переменная, в которой можно сохранить адрес какой-то другой переменной.

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

int a = 5; // объявляем переменную a типа int и присваиваем ей значение 5

int *ptr; // объявляем ptr как переменный указатель на переменную типа int

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

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

#include <iostream.h>

#include <string.h>

char *p = "stroka txt";

int main(void)

{ int t;

/* печать строки слева направо и справа налево

*/

cout<<p;

for(t=strlen(p)-1; t>-1; t--)

cout<< p[t];

return 0;}

26) Передача структур в функции. Создание массива структур.

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

При передаче членов структур в функции фактически передается значение члена. Следовательно, передается обычная переменная. Рассмотрим для примера следующую структуру: struct fred { char x; int y; float z; char s[10]; } mike;

Ниже приведены примеры передачи каждого члена в функцию: func(mike.х); /* передача символьного значения х */ func2(mike.у); /* передача целочисленного значения у */ func3(mike.z); /* передача вещественного значения z */ func4(mike.s); /* передача адреса строки s */ func(mike.s[2]); /* передача символьного значения s [2] */

Тем не менее, если необходимо передать адрес отдельного члена структуры, следует поместить оператор & перед именем структуры. Например, для передачи адреса элементов структуры mike следует написать: func(&mxke.x) ; /* передача адреса символа x */ func2(&mike.у); /* передача адреса целого у */ func3(&mike.z); /* передача адреса вещественного z */ func4(mike.s) ; /* передача адреса строки s */ func(&mike.s [2]); /* передача адреса символа s[2] */

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

Когда структура используется как параметр, самое важное - это запомнить, что тип аргумента должен соответствовать типу параметра. Лучший способ сделать это - определить структуру глобально, а затем использовать ее ярлык для объявления необходимых структурных переменных и параметров. Например: #include <iostream.h> /* объявление типа структуры */ struct type { int a, b; char ch; }; void fun(struct type parm); int main(void) { struct type arg;    /* объявление arg */ arg.a = 1000; fun(arg); return 0; } void fun(struct type parm) { cout<<parm.a; } Данная программа выводит число 1000 на экран. Можно видеть, что как arg, так и parm объявлены как структуры типа struct_type.

28) Циклы for. Циклы while. Циклы do-while. Разница между циклами.

Очень часто при написании какой-либо программы необходимо повторить какое-либо действие несколько раз. Например, необходимо посчитать сумму всех чисел от 1 до 1000. В таком случае целесообразно использовать циклы.

Если нам известно количество действий цикла, то в этом случае нам поможет цикл FOR

Его синтаксис :

for (действие до начала цикла;

условие продолжения цикла;

действия в конце каждой итерации цикла) {

инструкция цикла;

инструкция цикла 2;

инструкция цикла N;

}

Также существует частный случай этой записи

for (счетчик = значение; счетчик < значение; шаг цикла) {

тело цикла;

}

Счетчик — переменная, которая часто используется при выполнении цикла. Сперва начальному значению счетчика присваивается какое-либо значение, затем ставится точка с запятой. Далее мы задаем конечное значение счетчика цикла. Опять ставим точку с запятой. Теперь задаем шаг цикла. Шаг цикла — это значение, на которое будет увеличиваться или уменьшаться счетчик цикла при каждом выполнении итерации цикла. Итерацией цикла называется один проход цикла.

Допустим, нам необходимо посчитать сумму всех числе от 1 до 1000. Ниже приведен исходных код.

#include <iostream.h>

int main()

{

int i; // счетчик цикла

int sum = 0; // сумма чисел от 1 до 1000.

for (i = 1; i <= 1000; i++) // задаем начальное значение 1, конечное 1000 и задаем шаг цикла - 1.

{

sum = sum + i;

}

cout << "Сумма чисел от 1 до 1000 = " << sum << endl;

return 0;

}

Если мы скомпилируем этот код и запустим программу, то она покажет нам ответ: 500500. Это и есть сумма всех целых чисел от 1 до 1000. Если считать это вручную, понадобится очень много времени и сил, но Цикл выполнил всю рутинную работу за нас.

Когда мы не знаем, сколько итераций должен произвести цикл, нам понадобится цикл while или do...while. Синтаксис цикла while в C++ выглядит примерно так:

while (Условие) {

Тело цикла;

}

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

#include <iostream>

int main()

{

int i = 0; // инициализируем счетчик цикла.

int sum = 0; // инициализируем счетчик суммы.

while (i < 1000)

{

i++;

sum += i;

}

cout << "Сумма чисел от 1 до 1000 = " << sum << endl;

return 0;

}

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

30) Прототипы функций. Вызов функций по значению и вызов по ссылке. Область действия. Рекурсия.

Прототип функции (function prototype) — это объявление функции, но не ее определение. Благодаря явному объявлению возвращаемого типа и списка типов аргументов, в C++ при обращении к функции возможны строгая проверка типов и неявные преобразования типов.

Итак, функция может быть объявлена до того, как она определена. Определение функции может идти позже в этом же файле, браться из библиотеки или из указанного пользователем файла. Прототип функции имеет следующую форму:

тип имя(список_объявлений_аргументов);

список_объявлений_ аргументов может быть пустым, содержать единственное объявление или несколько объявлений, разделенных запятыми. Если функция не имеет параметров, допускается использование ключевого слова void. В C++ функ­ция с пустым списком параметров выглядит как имя_функции().

В языках программирования имеется два способа передачи значений подпрограмме. Первый из них — вызов по значению. При его применении в формальный параметр подпрограммы копируется значение аргумента. В таком случае изменения параметра на аргумент не влияют.

Вторым способом передачи аргументов подпрограмме является вызов по ссылке. При его применении в параметр копируется адрес аргумента. Это значит, что, в отличие от вызова по значению, изменения значения параметра приводят к точно таким же изменениям значения аргумента.

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

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

Простым примером является функция factr(), вычисляющая факториал целого числа. Факториал числа N является произведением чисел от 1 до N. Например, факториал 3 равен 1*2*3 или 6. Как factr(), так и его итеративный эквивалент показаны ниже: /* Вычисление факториала числа */ int factr(int n) /* рекурсивно */ { int otvet; if(n==1) return(1); otvet= factr(n-1)*n; return(otvet); } /* Вычисление факториала числа */ int fact (int n)    /* нерекурсивно */ { int t, otvet; otvet == 1; for(t=1; t<=n; t++) otvet=otvet*(t); return(otvet); }