Использование операторов break и continue
Оператор break имеет два применения:
1. окончание case в операторе switch
2. немедленное окончание цикла, не связанное с проверкой обычного условия выхода из цикла. Когда оператор break встречается внутри цикла, то происходит немедленный выход из цикла и переход к следующему по порядку оператору. Пример:
#include <iostream.h>
void main(void)
{
int i ;
for ( i=0 ; i<=1000 ; i++)
{
cout << i*i*i << endl;
if ( i*i*i >= 10000) break;
}
}
Оператор continue.
Если оператор continue встретился в цикле, происходит переход к следующей итерации цикла. В циклах while и do while - на проверку условия, в цикле for - на приращение шага. Этот оператор используется, если необходимо закончить текущую итерацию и не выполнять оставшиеся операторы, а сразу перейти к следующей итерации цикла.
Пример. Напечатать натуральные числа, кратные 7.
#include <iostream.h>
void main(void)
{
int i;
for ( i=1; i<1000; i++ )
{
if ( i%7 ) continue; / / или if ( i!=0 ) continue
cout << ²число ²<< i << ²кратно 7² << endl;
}
}
Оператор безусловного перехода goto.
Оператор goto в языке есть и иногда может быть полезен, хотя без него можно обойтись в любой ситуации. Для его использования необходима метка. Метка-это идентификатор, за которым следует двоеточие. Одно из применений goto - это выход из вложенных циклов.
for ( ) {
for ( ) {
. . .
goto exit;
. . .
}
}
exit: cout << ²быстрый выход из вложенных циклов²;
Массивы
Массив - это набор данных одного и того же типа, собранных под одним именем. Каждый элемент массива определяется именем массива и порядковым номером в этом массиве, который называется индексом. Индекс всегда целое число.
Объявление одномерного массива
тип имя_массива [ размер]
Объявление n-мерного массива
тип имя_массива [ размер1][ размер2]. . .[размер n] .
Мы знаем, что С++ позволяет инициализировать переменные при объявлении. То же верно и для массивов. При объявлении массива можно указать начальные значения, поместив их между фигурных скобок. Если массив инициализирован при объявлении, то используется 0 для индекса первого элемента массива, а индекс последнего элемента на 1 меньше размерности массива.
int a [5] = { 100, 200, 300, 400, 500 };
float b[3]={1. 1, 2. 2, 3. 3};
Если не указывать первоначальное значение элемента, программа будет инициализировать его с нулем. Если не указывать размер массива, который мы инициализируем, С++ сам определит количество ячеек памяти под массив.
int [ ] = { 1, 2, 3, 4, 5 }
Пример №1. Записать –1 вместо минимального элемента массива и подсчитать количество отрицательных элементов.
#include <iostream.h>
void main(void)
{
int i, n, kol = 0, nommin ; float a[100], min ;
cout <<” n=” ; cin >> n;
for ( i=1; i<=n; i++ )
{ cout << “введите” << i << “элемент массива” ; cin >> a[ i ]; }
min = a[1] ; nommin = 1;
for ( i=1; i<=n; i++ )
if ( ( a[i] < 0 ) { kol ++ ;
if ( a[ i ] < min) { min = a [ i ];
nommin = i ;
}
a[ nommin] = -1 ;
cout <<“\nизмененный массив :\n”
for ( i=1; i<=n; i++ ) cout << a[ i ];
cout << “ \nколичество отрицательных элементов: ” << kol;
}
|
|
#include<iostream.h>
#include<math.h>
void main ( )
{ int n, i, nom; float a[100], sr, sum = 0, min;
cout <<” введите количество элементов”;
cin >> n;cout << “ введите”<<n<<”чисел\n”;
for (i=1; i<=n; i++)
{cin >>a[i]; sum+=a[i];}
sr=sum/n;
min=fabs(sr – a[1]); nom = 1;
for (i=2; i<=n; i++)
{ if (fabs(sr – a[i])<min) { min= fabs(sr – a[i]) ; nom = i;}
}
cout <<” ближе всего к среднему” << nom << “элемент”;
}
Пример №3. Дано натуральное число. Получить новое число, записав цифры исходного числа в обратном порядке.
an 10n + an-1 10n-1 +… + a0 100 + a -1 10 -1 + …
#include<iostream.h>
#include<math.h>
void main ( )
{ int n, a[10], I=0, st, j;
cout << “введите натуральное число”; cin >> n;
while (n) // т.е. пока n ¹0
{ a[i++] = n – n/10*10; // последняя цифра
n/=10; //число без последней цифры
st = j = i – 1;
for ( i = 0; i < st; i++)
{ n+=a[I]*pow(10, j); j – – ; }
cout << “новое число :” << n;
}
Вложенные циклы.
Когда один цикл находится внутри другого, то говорят, что это вложенные циклы. Вложенные циклы часто встречаются при обработке таблиц чисел (матриц). Во вложенных циклах быстрее работают внутренние циклы.
Матрица – таблица чисел с адресами:
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] 2[2][2] a[2][3]
Двумерные массивы можно инициализировать при объявлении, например:
Int a[2][3]={1, 2, 2,
3, 4, 5 };
При этом левый верхний элемент матрицы имеет адрес a[0][0]
Матрицу можно заполнять с клавиатуры или использовать генератор случайных величин.
Пример №1. Дана действительная квадратная матрица порядка n. Выяснить, верно ли, что наибольшее из значений элементов главной диагонали больше, чем наименьшее из значений элементов побочной диагонали. Для заполнения матрицы будем использовать генератор случайных величин.
|
#include<iostream.h>
#include<stdlib.h>
#include<iomanip.h>
void main ( )
{ int n, a[10][10], i, j, max, min;
cout<<”введите размерность матрицы:”;
cin>>n;
randomize(); //инициализация генератора случайных величин
for ( i = 1; i <=n; i++)
{
for ( j = 1; j <=n; j++)
{
a[i][j]=random(100)-random(100);
cout << setw(5)<<a[i][j];
}
cout<<endl;
}
max=a[1][1]; min=1[1][n];
for ( i = 1; i <=n; i++)
if ( a [i] [i] > max) max = a[i][i];
for ( i = 1, j=n; i <=n; i++, j--)
if ( a [i] [j] < min) min = a[i][j];
if (max > min) cout<<”верно”;
else cout << “неверно”;
}
При вводе матрицы с клавиатуры можно использовать функции позиционирования курсора в нужное место экрана, чтобы при вводе числа отображались в виде таблицы. Для этого используется заголовочный файл <conio.h> , который содержит функции:
gotoxy(a, b) перемещает курсор в позицию а строки в
wherex() , wherey() возвращают координаты x, y текущего положения курсора.
сlrscr() очистка экрана
Пример №2. Дана действительная матрица размера n´m. Найти среднее арифметическое положительных элементов каждого столбца матрицы. Ввод матрицы с клавиатуры с использованием позиционирования курсора.
#include <iostream.h>
#include <conio.h>
void main(void)
{
int a[10][10], i, j, n, m, kol, sum; float sr;
cout <<”введите количество строк”; cin >> n;
cout << “введите количество столбцов”; cin >> m;
for ( i = 1; i <=n; i++)
{
for ( j = 1; j <=n; j++)
{ gotoxy(wherex()+5*j, wherey()-1);
cin >> a[i][j];
}
cout << endl;
}
for(j = 1; j <= n; j++)
{
sum = kol = 0;
for ( I = 1; I < = m; i++)
if (a[i][j]>0)
{
sum+= a[i][j];
kol++;
}
if (kol ==0) cout << ²в столбце номер ² << j << ² нет положительных элементов²;
else
{
sr=sum/kol;
cout << ²в столбце номер ² << j << ² ср арифм полжит элементов=² << sr;
}
}
Вложенные циклы используются не только для обработки матриц.
Пример №3. Получить все числа, которые входят в последовательность по одному разу.
#include <iostream.h>
#include <iomanip.h>
void main(void)
{
int n=20;
int a[20]; // исходный массив А
int b[20]; // массив из чисел, которые не повторяются
int i, j; // параметры циклов
int k; // количество неповторений
int nom = 0; // номер элемента в массиве В
for ( i = 0; i < n; i++)
{cout << ²введите ² << i << ² элемент массива : ² ; cin >> a[i];
}
for (i=0; i<n; i++)
{ k=1;
for (j=1; j<n; j++) if (a[i]!=a[j]) k++;
if (k ==n-1) b[nom++]=a[i];
}
cout << ² массив из чисел, которые не повторяются: ² ;
for ( i=0; i< nom; i++)
cout << setw(8)<<b[i];
}
Пример №4. Отсортировать массив (расположить элементы в порядке возрастания)
#include <iostream.h>
#include <stdlib.h>
#include <iomanip.h>
void main(void)
{
int a[10], i, j, x;
randomize(); // заполнение массива случайными числами
cout << ² исходный массив: ² << endl;
for (i=0; i<10; i++)
{ a[i]=random(30)-random(30);
cout << setw(8) << a[i]; }
for ( i=0; i<9; i++)
for ( j=i; j<10; j++)
if (a[j+1]<a[j])
{
x=a[j]; a[j]=a[j+1]; a[j+1]=x;
}
cout << ²отсортированный массив : ² << endl;
for ( i=0; i<10; i++) cout << setw(8) << a[i];
}
Указатели.
(Понимание и правильное использование указателей очень важно для создания хороших программ на С++. Указатели необходимы для успешного использования функций и динамического распределения памяти.)
Указатель – это переменная, которая содержит адрес некоторого объекта.Здесь имеется в виду адрес в памяти компьютера. Если переменная будет указателем, она должна быть соответствующим образом объявлена. Указатель объявляется следующим образом:
тип *<имя переменной>
Тип-это некоторый тип языка С++
* означает, что следующая за ней переменная является указателем Например:
char *ch // идентификатор ch указывает на объект типа char
int *temp, i, *j // i-переменная типа int; temp , j - указатели на // объект типа int
float *f // f-указатель на объект типа float
С указателями связаны две операции: & и *
Обе эти операции являются унарными, т. е. имеют один операнд, перед которым они ставятся. Операция & соответствует операции «взять адрес», операция * – разыменование, означает «извлчь значение, расположенное по указанному адресу» . Простейшие действия с указателями в программе:
#include <iostream.h>
void main(void)
{
int x, y, *px;
x=2;
px=&x; //px содержит адрес переменной х (х=2)
y=*px; // извлечь значение, находящееся по адресу рх и записать ее в у // y=2
*px=10; // x=10
}
Тот же самый результат можно получить без использования указателей:
#include <iostream.h>
void main(void)
{
int x, y;
x=2;
y=x;
}
Унарная операция * может использоваться в левой части оператора присваивания для того, чтобы какие-то данные были сохранены в области памяти, на которую показывает указатель.
Пример.
#include <iostream. h>
void main(void)
{
int x, *px;
px=&x; // px содержит адрес переменной х
*px=10; // изменить значение, находящееся по адресу рх(в результате х=10)
}
В языке С++ существует связь между массивами и указателями. Имя массива – это адрес памяти, начиная с которого расположен массив, т. е. Имя массива является указателем еа первый элемент массива. Если объявлен массив а:
int a[10];
то идентификатор а является указателем на массив, точнее на первый элемент массива
Операторы
int a[10], *pa;
pa=a и pa=&a[0] приведут к одному и тому же результату.
Для того, чтобы получить значение 6-го элемента массива «а», можно написать:
a[5] или *(a+5)
Преимущество второго варианта в том, что арифметические операции над указателями выполняются быстрее, если мы работаем с подряд идущими элементами массива.
Если выбор элементов массива случайный, то быстрее работа с индексами.
Функции.
Функция -это часть программы, предназначенная для решения определенной задачи. Обычно функция вызывается несколько раз. Стандартные математические функции находятся в файле <math.h>. В программе функции находятся перед функцией main. Общий вид функции:
тип < имя функции > (список параметров)
{
объявления переменных;
операторы;
}
тип- тип значения, которое возвращает функция с помощью оператора return
список параметров состоит из перечня типов и имен параметров, разделенных запятыми. Функция может не иметь параметров и не возвращать значение, например
void main(void); void означает «пустой». Выполнение программы всегда начинается с главной функции main. Если в программе встречается вызов функции, выполняются операторы, находящиеся внутри функции, после завершения функции программа продолжает работу с оператора, следующего за именем функции.
Пример№1
#include <iostream.h>
void show(void)
{
cout << ² Borland C++ ² << endl;
}
void main(void)
{
cout << ² перед вызовом функции ² << endl;
show(); // обращение к функции
cout << ² после функции ² << endl;}
В результате будет напечатано:
перед вызовом функции
Borland C++
после функции
Программа может передавать информацию в функцию. Параметры функции перечисляются в круглых скобках после ее имени, причем для каждого параметра указывается его тип. Например:
f(int x, int y, float z); нельзя перечислять параметры одного типа через запятую.
Пример №2.
#include <iostream.h>
void show_number ( int a)
{
cout << ² значение параметра а= ² << endl;
}
void main(void)
{
show_number(1); show_number(1001); show_number(-500);
}
будет напечатано:
значение параметра а=1
значение параметра а=1001
значение параметра а= -500
Функция может возвращать результат. В этом случае необходимо указать тип результата, а для передачи результата в функции используется оператор return.Оператор return может иметь параметры или не иметь.
Если оператор return встретился в функции, это означает немедленный выход из функции и возврат в вызывающую программу. В теле функции может быть несколько операторов return, может быть ни одного.
Пример №3. Функция, которая возводит число а в натуральную степень b:
a × a × … × a
b раз
#include<iostream.h>
float step (float a, int b)
{
int i; float f=1;
for ( i=1; i<abs(b); i++) f*=a;
if (b>=0)return f;
else return (1/f);
}
void main () { cout <<”3.2^5=”<<step(3.2,5);}
В программе можно использовать возвращаемое функцией значение, запоминая его в переменной с помощью оператора присваивания:
rezult=step(3, 5);
Можно использовать вызов функции в операторе cout:
cout << «3^5=» << step(3, 5) << endl;
Программа может использовать функцию в условном операторе:
if ( max(a, b)<100) . . .
Можно в самом начале программы поместить прототип функции, а сама функция может быть задана в другом месте программы. Прототип указывает тип возвращаемого значения, имя функции, количество и тип каждого параметра. Чаще всего прототип совпадает с заголовком в описании функции. Прототип может выглядеть так: float func(int a, float b); или так:
float func(int, float);
Эти два объявления абсолютно равносильны.
Пример №4. Функция возведения в квадрат.
#include < iostream.h>
float sqr(float); // прототип функции
void main(void)
{
float b;
cout << ² введите число: ²
cin >> b;
cout << ² b^2= ² << sqr(b) << endl;
}
float sqr(float a); // описание функции
{
return a*a;
}
Область действий переменной.
Область действий – это правила, которые устанавливают, какие данные доступны из определенного места программы. С точки зрения области действия переменных различают три типа переменных: глобальные, локальные и формальные параметры (переменные).
Локальные переменные – это переменные, объявленные внутри блока, в частности внутри функции. Локальная переменная доступна внутри блока, в котором объявлена Блок открывается и закрывается с помощью фигурных скобок. Локальная переменная существует, пока выполняется блок, в котором она объявлена. При выходе из блока эта переменная и ее значение теряется.
Пример №5.
#include <iostream.h>
void func(void); //прототип функции
void main(void)
{
int i=1; //локальная переменная
func();
cout << ²В функции main значение i=² << i << endl;
}
void func(void)
{
int i=10; //локальная переменная
cout << ² в функции func значение i=² << i << endl;
}
Будет напечатано:
в функции func значение i=1
в функции main значение i=10
Формальные параметры – это переменные, объявленные при описании функции как ее аргументы. Функции могут иметь некоторое количество параметров, которые используются при вызове функций для передачи значений в тело функции. Формальные параметры могут использоваться в теле функции так же, как локальные переменные, которыми они по сути являются. Область действия формальных параметров – блок, являющийся телом функции. Существуют фактические параметры – это параметры, которые передаются в функцию при ее вызове.
Глобальные переменные – это переменные , объявленные вне какой-то функции.
В отличие от локальных переменных глобальные переменные могут быть использованы в любом месте программы, но перед их использованием они должны быть объявлены. Область действия глобальной переменной -вся программа. Имя локальной и глобальной переменной может совпадать, в этом случае приоритет предоставляется локальной переменной. В случае, если необходимо обратиться к глобальной переменной , чье имя совпадает с именем локальной переменной внутри функции, можно использовать глобальный оператор разрешения С++(::)
Пример №6.
#include <iostream. h>
int a=1001; // глобальная переменная а
void show(int a) // локальная переменная а
{
cout << ² локальная переменная а=² << a << endl;
cout << ² глобальная переменная а=² << ::a << endl;
}
void main(void)
{
int b=2002;
show(b);
}
результат:
локальная переменная а=2002
глобальная переменная а=1001
Модификаторы переменных.
В языке С имеется несколько модификаторов, которые изменяют область действия и время жизни переменных.
| Модификатор | применение | область действия | выделение памяти | объяснение |
| auto | локальная переменная | блок | временное | для локальных переменных применяется по умолчанию |
| register | локальная переменная | блок | временное | предполагается, что переменная располагается в машинном регистре |
| extern | блок | информирует компилятор, что переменная определяется в другом блоке | ||
| static | локальная переменная | блок | постоянное | область действия соответствует локальной переменной, а время жизни -глобальной |
| static | глобальная переменная | файл | постоянное | ограничивает область действия глобальной переменной текущим файлом |
Пример №7: определить, сколько целых чисел в интервале от 1 до 500 являются степенью цифры 3.
27=33, 81=34
#include <iostream.h>
#include <math.h>
int step3(int a)
{
if (pow(а, 1./3.)==int(pow(а, 1./3.))) return 1;
return 0;
}
void main ()
{ int i, kol=0;
for (i=1; i<=500; i++)
if (step3(i) != 0)
{cout << setw(5)<<i; kol++;}
cout << kol-1 << “чисел – степени тройки”;
}
Пример №8. Вычислить f(x,y)+f(x-y,x/y), где 
#include <iostream.h>
#include <math.h>
float f(float a, float b) //a, b формальные параметры
{
float f= fabs(a+b)/(a*b);return f; } // f локальный параметр
void main ()
{ float x, y, z; //x, y, z локальные параметры
cout << “введите два числа”;cin>>x>>y;
z=f(x,y)+f(x-y,x/y);
cout<<z;
}