Тело_цикла
Все операторы цикла содержат тело_цикла и условие.
Тело_цикла – это отдельный оператор (в т.ч. и пустой), который заканчивается точкой с запятой, либо составной оператор, который заключается в фигурные скобки.
Условие – это скалярное выражение (чаще всего отношение или арифметическое выражение), определяющее условие продолжения выполнения итераций (если его значение не равно нулю). Условие может быть достаточно сложным, состоять из нескольких выражений, разделенных запятой (в этом случае принимается решение по последнему выражению).
4.3.1 Оператор цикла while
Оператор while – это оператор с предусловием(повторять тело цикла до тех пор, пока условие истинно). При входе в цикл вычисляется выражение-условие. Если его значение отлично от нуля, то выполняется тело цикла. Затем снова вычисляется условие, и выполнение цикла повторяется до тех пор, пока значение условия не станет равным нулю. Блок-схема работы оператора с предусловием:
Пример. Вычисляем сумму чисел, кратных 5.
int i=0, S5=0;
while(i<5)
{i++; printf("%d ",i); // 1 2 3 4 5
S5 +=5*i; // 5 15 30 50 75 (5+10+15+20+25)
}
printf(“i=%d S5=%d\n”,i,S5); } //i=5 S5=75
Внутри цикла могут стоять операторы continue, break, return.
Оператор continue заставляет пропустить остаток тела цикла и перейти к следующей итерации (повторению).
Пример. Находим сумму первых четырех нечетных чисел, которые вводятся с клавиатуры, а также число четных и нечетных вводимых чисел.
int n1=0,n2=0,a,sum=0;
while(n1<4)
{scanf("%d",&a); // пусть будем вводить 1 2 3 4 5 6 7
if(a%2==0) // при четном числе
{n2++; // 1 2 3 (числа 2, 4, 6)
continue;}
n1++; // 1 2 3 4
sum+=a; } // 1 4 9 16 (1 + 3 + 5 + 7)
printf("n1=%d n2=%d sum=%d\n", n1, n2, sum);}
// n1=4 n2=3 sum=16
Оператор break завершит выполнение цикла.
Пример. Находим произведение чисел, которые вводятся с клавиатуры, при вводе 0 цикл завершается.
int i=0, n=0, a, Pr=1;
while(i<4)
{scanf("%d",&a); // пусть будем вводить 2 3 4 5 или 2 3 0
if(a==0) {n=1; break;}
i++; // 1 2 3 4 или 1 2
Pr*=a; } // 2 6 24 120 (2 * 3 * 4 * 5) или 2 6 (2 * 3)
printf("n=%d i=%d Pr=%d\n",n,i,Pr); }// n=0 i=4 Pr=120
// или n=1 i=2 Pr=6
Оператор return завершит выполнение всей программы.
Пример. Находим частное от деления 1.0 на числа, которые вводятся с клавиатуры, при вводе 0 программа завершается.
int i=0;
float b, div=1.0;
while(i<4)
{scanf("%f",&b); // пусть будем вводить 2 2 4 5 или 2 2 0
if(b==0.0) {puts("Деление на 0"); return;}
i++; // 1 2 3 4 или 1 2
div/=b; } // 0. 5 0. 25 0. 0625 0. 0125 (1 / 2 / 2 / 4 / 5) или 0. 5 0. 25
printf("%d %f\n",i,div); // 4 0.0125 или Деление на 0
}
4.3.2 Оператор цикла do…while
Оператор do…while может обеспечить хотя бы одно выполнение тела цикла, т.к. сначала выполняется тело цикла, затем вычисляется выражение-условие, и если оно истинно, то тело цикла выполняется вновь, до тех пор, пока условие не станет равным нулю.
Блок-схема работы оператора с постусловием
Пример. К начальному значению m добавляется 1, пока m меньше 4.
int m=1;
do{printf("m=%d ",m);.// m=1 m=2 m=3
m+=1; // 2 3 4
}while (m<4); // цикл выполнится три раза
Пример. К начальному значению m добавляется 1, пока m меньше 4.
int m=10;
do{printf("m=%d",m); // m=10
m++; // 11
}while (m<4); // цикл выполнится один раз
В этом операторе также можно использовать операторы break, continue, return.
4.3.3 Оператор цикла for
Конструкция оператора итерационного цикла следующая:
For(инициализация_цикла; условие;список выражений)
Тело_цикла
Оператор начинается с ключевого слова for, после которого в круглых скобках написаны три выражения, разделенные точкой с запятой.
инициализация_цикла – это последовательность определений, описаний и выражений, разделенных запятыми. Она выполняется один раз до начала выполнения цикла. Тело цикла будет повторяться до тех пор, пока условие не станет равным нулю. Список выражений вычисляется после каждого повторения тела цикла. условие может отсутствовать, в этом случае считается, что его значение истинно.
Блок-схема работы оператора итерационного цикла
Пример. Находим сумму четырех чисел, кратных 10, начиная с 0.
int i, sum=0;
for(i=0; i<4; i++) // 1 2 3 4
sum+=10*i; // 0 10 3 0 60 (0 + 10 + 20 + 30)
Пример. Находим сумму трех двоек и трех значений переменной n.
int s1=0,s2=0;
for(int i=0,n=5; n<6,i<3; i++,s1+=2) // s1=2 4 6
s2+=++n; // 6 13 21 (6 + 7 + 8)
В этом операторе также можно использовать операторы break, continue, return.
Любое из трех выражений может быть опущено (в том числе и все три). В этом случае получим бесконечный цикл, из которого можно выйти, воспользовавшись операторами break, return.
Все операторы цикла взаимозаменяемы.
Разрешено и широко используется вложение любых циклов в любые циклы. Допускаются вложенные циклы на любую глубину.
4.4 Оператор безусловного перехода
Синтаксис этого оператора следующий: goto имя_метки;
где имя_метки – метка оператора, которому передается управление.
Передача управления разрешена на любой помеченный меткой оператор в теле функции. Однако запрещено перескакивать через описания, содержащие инициализацию объектов. Есть ряд рекомендаций к использованию оператора goto: не входить во внутрь блока, условного оператора, переключателя, цикла.
Пример.
if(n>=n_max) goto M1; // переход на М1, если n>=n_max
n++;
M1: printf("n=%d ", n);
Массивы
5.1 Одномерные массивы
Массив – это совокупность переменных одного типа, элементы которого имеют одно имя и отличаются только индексом.
Синтаксис определения массива: тип имя_массива[размер];
где тип – один из базовых или производных типов,
размер – целочисленное константное выражение, определяющее количество элементов в массиве.
Три способа задания размера массива:
1) целой числовой константой или целочисленным выражением;
int a1[10]; // массив элементов типа int, состоящий из 10 элементов
2) именованной константой – со служебным словом const;
const int M=4;
float f1[M];// состоит из 4 элементов типа float
3) с помощью препроцессорной директивы #define.
#define N 20
char c1[N]; // массив, содержащий 20 символов.
Доступ к элементам массива осуществляется через индексы. Перечисление элементов массива начинается с нуля. Индексы должны быть целочисленными выражениями. В массиве a1 – первый элемент a1[0], последний – a1[9].
В памяти машины компилятор размещает массив в последовательных ячейках (непрерывным блоком). Например: int m[3];
Их размещение в памяти схематично можно представить так:
| m[0] | m[1] | m[2] |
Массивы бывают разного класса памяти. Массивы, определенные вне функций, в том числе вне функции main(), являются глобальными (внешними). Массивы, которые определены внутри функции, могут быть статическими (с словом static) или автоматическими.
Пример.
int a1[5];// массив внешний
Void main()
{float b1[4]; // массив автоматический
static long c1[3]; // массив статический
…}
Инициализация массива – присвоение начальных значений элементам при определении массива.
Элементы массива инициализируются неявно и явно. Неявно (по умолчанию) внешние и статические массивы инициализируются нулями, а массивы с автоматическим классом памяти – случайными, произвольными значениями.
Явная инициализация выполняется только при определении массива, она может быть полной и неполной. После определения массива ставится знак = и в фигурных скобках через запятую задаются значения элементов. При неполной инициализации незаданные элементы массива принимают нулевое значение, если массив внешний или статический, или случайные значения, если массив автоматический. При полной инициализации размер массива можно не указывать, он определиться автоматически. Например:
int а2[5]={1,5,4,3,2}; // полная инициализация
int а3[7]={1,5,2,7}; // неполная инициализация
int с[]={3,4,5}; // полная инициализация без указания размера массива
Объем памяти в байтах, занимаемый массивом можно определить с помощью операции sizeof(имя_массива). Например:
int n=sizeof(а2);// 20 байт
Для работы с массивами часто применяются операторы цикла, наиболее часто используется оператор цикла for. Рассмотрим примеры различных фрагментов программ:
Пример. Определение суммы элементов массива
#include <stdio.h>
Void main()
{int a[10],sum=0;
for(int i=0;i<10;i++)
scanf("%d",&a[i]);// ввод массива с клавиатуры
for(i=0;i<10;i++)
sum+=a[i]; // подсчет суммы
printf("%d\n",sum);}
Пример. Поиск максимального значения элементов массива
#define N 5
#include<iostream>
#include<time.h> // для запуска генератора случайных чисел
#include<stdlib.h> // для подключения генератора случайных чисел
#include <stdio.h>
Void main()
{float fa[N],max; int k=0;
srand((unsigned)time(NULL));
printf("массив fa\n");
for(int i=0;i<N;i++)
{fa[i])=rand()%1001*0.1-50.0;// случайные числа от -50.0 до +50.0
printf("fa[%d]=%f\n",i,fa[i]); } // вывод массива на экран
max=fa[0]);
for(int i=1;i<N;i++)
if(fa[i]>max) {max=fa[i]; k=i;}
printf("\n%d элемент массива max=%f\n",k,max);
}
5.2 Символьные массивы и строки
Символьные массивы ‑ это массивы, элементами которых являются переменные типа char.
char ch[3]={10,20,30};
char symb[5]={'a','b','c','d','e'};
Строка ‑ это массив элементов типа char, в котором последним элементом является символ '\0'. Если строка содержит N символов, то в памяти под неё отведено N+1 байт. Строки инициализируются последовательностью символов в двойных кавычках: char ch[]="abcd";
Пример.
#include <stdio.h>
Void main()
{char BC[]="BORLAND C++";
printf("%c%c%d\n",BC[0],BC[10],sizeof(BC));// B+12
printf("%s\n",BC); } // BORLAND C++
Вводить строки и массивы символов можно разными способами.
Пример. Ввод массива символов поэлементно.
#include <stdio.h>
Void main()
{char ac[20];
printf("Введите 20 символов\n");
for(int k=0;k<20;k++)
ac[k]=getch(); // ввод символа без Enter и без вывода на экран
//ac[k]=getche();// ввод символа без нажатия Enter и с выводом на экран
//ac[k]=getchar(); // или ввод символа с нажатием клавиши Enter;
//scanf("%c", &arrc[k]);// или с помощью спецификатора %c.
}
Надо помнить, что в конце массива, введенного такими способами, не будет символа конца строки '\0'. Поэтому вывод этих массивов на экран надо выполнять в цикле с помощью функций putch(), putchar() или printf() co спецификатором формата %c:
for(k=0;k<n;k++)
printf("%c",ac[k]); // putchar(ac[k]); // putch(ac[k]);
Строки можно вводить и выводить с помощью спецификатора %s:
scanf("%s",ac); // ввод строки до нажатия пробела
printf("%s\n",ac); // вывод строки
Строки удобно вводить и выводить с помощью функций gets(), puts(), а также используя потоковые операторы языка С++:
char name[50]; char str[20];
puts("Введите Ф И О")
gets(name); // ввод строки до нажатия клавиши Enter
puts(name); // вывод строки
cout<<"Введите ваш адрес\n";
cin>>str; // ввод строки до нажатия клавиши Enter
cout<<str; // вывод строки
Для работы со строками в языке Си имеются функции, которые описаны в заголовочном файле string.h. Рассмотрим наиболее часто используемые функции работы со строками.
Функция strcpy(s1,s2) копирует содержимое строки s2 в строку s1. При этом массив s1 должен иметь размер, достаточный для размещения строки s2.
char s1[20],s2[10]="История";
strcpy(s1,s2); puts(s1);
Функция strlen(s) вычисляет длину строки s, при этом нулевой байт не учитывается. Например:
int len=strlen("ПРИВЕТ"); // len=6
Функция strcmp(s1,s2) сравнивает строки s1 и s2 и возвращает 0, если строки равны, т.е. содержат одно и то же число одинаковых символов в одинаковом порядке. Если первая строка лексикографически (в смысле словаря) больше второй, то функция возвращает положительное число, если меньше ‑ отрицательное. Например:
char s1[30], s2[30];
puts("Введите 1-ую строку"); gets(s1);
puts("Введите 2-ую строку"); gets(s2);
puts("Введены строки:");
puts(s1); puts(s2);
int flag=strcmp(s1,s2);
if(flag==0) puts("s1==s2");
else if(flag>0) puts("s1>s2");
else puts ("s1<s2");
Если ввести 1 строку "abc", 2 строку "abc", то получим "s1==s2";
Если ввести 1 строку "abcd", 2 строку "bcd", то получим "s1<s2";
Если ввести 1 строку "bcс", 2 строку "aa", то получим "s1>s2";
Функция strcat(s1,s2) присоединяет (конкатенирует) строку s2 к строке s1 и помещает получившуюся строку в строку s1. Нулевой байт, который завершал строку s1, будет в результате замещен первым символом строки s2. Здесь так же необходимо следить, чтобы в строке s1 хватило места для объединенной строки.
char s1[50]="Сегодня - ", s2[15]="понедельник";
strcat(s1,s2);