Что такое цикл в с
Перейти к содержимому

Что такое цикл в с

  • автор:

Что такое цикл в с

Циклы позволяет выполнить одно действие множество раз в зависимости от определенного условия. В языке Си есть следующие типы циклов:

Цикл for

Цикл for имеет следующее формальное определение:

for (инициализация; условие; приращение;) < // тело цикла >

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

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

Третья часть — приращение задает изменение параметров цикла. Обычно здесь происходит увеличение счетчиков цикла.

Рассмотрим стандартный цикл for и для этого выведем числа с 0 до 5 на консоль:

#include int main(void) < for (int i = 0; i < 6; i++) < printf("%d", i); >return 0; >

Первая часть объявления цикла — int i = 0 — создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 0. В данном случае это то же самое, что и объявление переменной.

Вторая часть — условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 6.

И третья часть — приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i—. Можно изменять на другое значение: i+=2.

В итоге блок цикла сработает 6 раз, пока значение i не станет равным 6. И каждый раз это значение будет увеличиваться на 1.

012345

Каждый отдельный проход цикла называется итерацией. То есть в примере выше было 6 итераций.

Усложним цикл и выведем квадраты чисел от 0 до 8:

#include int main(void) < for (int i = 0; i < 9; i++) < printf("%d * %d = %d \n", i, i, i * i); >return 0; >

Здесь блок цикла сработает 9 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.

0 * 0 = 0 1 * 1 = 1 2 * 2 = 4 3 * 3 = 9 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64

Необязательно указывать все три выражения в определении цикла, мы можем одно или даже все их них опустить:

int i = 1; for ( ; i

Формально определение цикла осталось тем же, только теперь первое и третье выражения в определении цикла отсутствуют: for (; i < 9;) . Переменная-счетчик определена и инициализирована вне цикла, а ее приращение происходит в самом цикле.

Можно определять вложенные циклы. Например, выведем таблицу умножения:

#include int main(void) < for (int i=1; i < 10; i++) < for(int j = 1; j < 10; j++) < printf("%d \t", i * j); >printf("\n"); > return 0; >

Цикл do..while

В цикле do..while сначала выполняется код цикла, а потом происходит проверка условия в инструкции while . И пока это условие истинно, то есть не равно 0, то цикл повторяется.

do < // действия цикла >while (условие);
#include int main(void) < int i = 6; do < printf("%d", i); i--; >while (i > 0); return 0; >

Здесь код цикла сработает 6 раз, пока i не станет равным нулю. Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий, даже если перед первым выполнением условие в инструкции while не будет истинно. То есть мы можем написать:

int i = -1; do < printf("%d", i); i--; >while (i > 0);

Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.

Цикл while

В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то есть не равно 0, то код цикла выполняется:

while(условие) < // выполняемые инструкции, если условие истинно >

Например, выведем на консоль все числа от 6 до 1:

#include int main(void) < int i = 6; while (i >0) < printf("%d \n", i); i--; >return 0; >

Здесь, пока истинно условие i > 0 , будут выполняться действия цикла — printf(«%d \n», i) и i—

Операторы continue и break

Иногда возникает необходимость выйти из цикла до его завершения. В этом случае можно воспользоваться оператором break . Например:

int i = 1; for ( ; ; ) < printf("%d * %d = %d \n", i, i, i * i); i++; if (i >5) break; >

Здесь когда значение переменной i достигнет 5, осуществляется выход из цикла с помощью оператора break .

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

#include int main(void) < int result = 0; for (int i=0; iprintf("result = %d", result); // 25 return 0; >

Чтобы узнать, четное ли число, мы получаем остаток от целочисленного деления на 2, и если он равен 0, то с помощью оператора continue переходим к следующей итерации цикла. А если число нечетное, то складываем его с остальными нечетными числами.

Что такое цикл в с

Циклы являются управляющими конструкциями, позволяя в зависимости от определенных условий выполнять некоторое действие множество раз. В C# имеются следующие виды циклов:

Цикл for

Цикл for имеет следующее формальное определение:

for ([действия_до_выполнения_цикла]; [условие]; [действия_после_выполнения]) < // действия >

Объявление цикла for состоит из трех частей. Первая часть объявления цикла — некоторые действия, которые выполняются один раз до выполнения цикла. Обычно здесь определяются переменные, которые будут использоваться в цикле.

Вторая часть — условие, при котором будет выполняться цикл. Пока условие равно true , будет выполняться цикл.

И третья часть — некоторые действия, которые выполняются после завершения блока цикла. Эти действия выполняются каждый раз при завершении блока цикла.

После объявления цикла в фигурных скобках помещаются сами действия цикла.

Рассмотрим стандартный цикл for:

for (int i = 1; i

Здесь первая часть объявления цикла — int i = 1 — создает и инициализирует переменную i.

И третья часть — действия, выполняемые после завершения действий из блока цикла — увеличение переменной i на единицу.

Весь процесс цикла можно представить следующим образом:

В итоге блок цикла сработает 3 раза, пока значение i не станет равным 4. И каждый раз это значение будет увеличиваться на 1. Однократное выполнение блока цикла называется итерацией . Таким образом, здесь цикл выполнит три итерации. Результат работы программы:

1 2 3

Если блок цикла for содержит одну инструкцию, то мы можем его сократить, убрав фигурные свобки:

for (int i = 1; i < 4; i++) Console.WriteLine(i); // или так for (int i = 1; i < 4; i++) Console.WriteLine(i);

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

var i = 1; for (Console.WriteLine("Начало выполнения цикла"); i < 4; Console.WriteLine($"i = "))

Здесь опять же цикл срабатывает, пока переменная i меньше 4, только приращение переменной i происходит в блоке цикла. Консольный вывод данной программы:

Начало выполнения цикла i = 2 i = 3 i = 4

Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:

int i = 1; for (; ;) < Console.WriteLine($"i = "); i++; >

Формально определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; 😉 . У нас нет инициализированной переменной, нет условия, поэтому цикл будет работать вечно - бесконечный цикл.

Мы также можем опустить ряд блоков:

int i = 1; for (; i<4;) < Console.WriteLine($"i = "); i++; >

Этот пример по сути эквивалентен первому примеру: у нас также есть переменная-счетчик, только определена она вне цикла. У нас есть условие выполнения цикла. И есть приращение переменной уже в самом блоке for.

Также стоит отметить, что можно определять несколько переменных в объявлении цикла:

for (int i = 1, j = 1; i < 10; i++, j++) Console.WriteLine($"");

Здесь в первой части объявления цикла определяются две переменных: i и j. Цикл выполняется, пока i не будет равна 10. После каждой итерации переменые i и j увеличиваются на единицу. Консольный вывод программы:

1 4 9 16 25 36 49 64 81

Цикл do..while

В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, цикл повторяется.

do < действия цикла >while (условие)
int i = 6; do < Console.WriteLine(i); i--; >while (i > 0);

Здесь код цикла сработает 6 раз, пока i не станет равным нулю. Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий, даже если условие в инструкции while не будет истинно. То есть мы можем написать:

int i = -1; do < Console.WriteLine(i); i--; >while (i > 0);

Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.

Цикл while

В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:

while (условие)
int i = 6; while (i > 0)

Цикл foreach

Цикл foreach предназначен для перебора набора или коллекции элементов. Его общее определение:

foreach(тип_данных переменная in коллекция) < // действия цикла >

После оператора foreach в скобках сначала идет определение переменной. Затем ключевое слово in и далее коллекция, элементы которой надо перебрать.

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

Например, возьмем строку. Строка по сути - это коллекция символов. И .NET позволяет перебрать все элементы строки - ее символы с помощью цикла foreach .

foreach(char c in "Tom")

Здесь цикл foreach пробегается по всем символам строки "Tom" и каждый символ помещает в символьную переменную c . В блоке цикла значение переменной c выводится на консоль. Поскольку в строке "Tom" три символа, то цикл выполнится три раза. Консольный вывод программы:

T o m

Стоит отметить, что переменная, которая определяется в объявлении цикла, должна по типу соответствовать типу элементов перебираемой коллекции. Так, элементы строки - значения типа char - символы. Поэтому переменная c имеет тип char . Однако в реальности не всегда бывает очевидно, какой тип представляют элементы коллекции. В этом случае мы можем определить переменную с помощью оператора var :

foreach(var c in "Tom")

В дальнейшем мы подробнее рассмотрим, что представляют собой коллекции в .NET и какие именно коллекции можно перебирать с помощью цикла foreach .

Операторы continue и break

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

for (int i = 0; i

Хотя в условии цикла сказано, что цикл будет выполняться, пока счетчик i не достигнет значения 9, в реальности цикл сработает 5 раз. Так как при достижении счетчиком i значения 5, сработает оператор break, и цикл завершится.

0 1 2 3 4

Теперь поставим себе другую задачу. А что если мы хотим, чтобы при проверке цикл не завершался, а просто пропускал текущую итерацию. Для этого мы можем воспользоваться оператором continue :

for (int i = 0; i

В этом случае цикл, когда дойдет до числа 5, которое не удовлетворяет условию проверки, просто пропустит это число и перейдет к следующей итерации:

0 1 2 3 4 6 7 8

Стоит отметить, что операторы break и continue можно применять в любом типе циклов.

Вложенные циклы

Одни циклы могут быть вложенными в другие. Например:

for (int i = 1; i < 10; i++) < for (int j = 1; j < 10; j++) < Console.Write($"\t"); > Console.WriteLine(); >
  • Вопросы для самопроверки
  • Упражнения
  • Глава 1. Введение в C#
    • Язык C# и платформа .NET
    • Первая программа на C# с .NET CLI
    • Начало работы с Visual Studio. Первая программа
    • Первая программа на MacOS
    • Первая программа на Linux
    • Первое приложение в WSL
    • Структура программы
    • Переменные и константы
    • Литералы
    • Типы данных
    • Консольный ввод-вывод
    • Арифметические операции
    • Поразрядные операции
    • Операции присваивания
    • Преобразования базовых типов данных
    • Условные выражения
    • Конструкция if..else и тернарная операция
    • Циклы
    • Массивы
    • Задачи с массивами
    • Методы
    • Параметры методов
    • Возвращение значения и оператор return
    • Передача параметров по ссылке и значению. Выходные параметры
    • Массив параметров и ключевое слово params
    • Рекурсивные функции
    • Локальные функции
    • Конструкция switch
    • Перечисления enum
    • Классы и объекты
    • Конструкторы, инициализаторы и деконструкторы
    • Класс Program и метод Main. Программы верхнего уровня
    • Структуры
    • Типы значений и ссылочные типы
    • Область видимости (контекст) переменных
    • Пространства имен
    • Глобальные пространства имен
    • Подключение пространств имен по умолчанию
    • Создание библиотеки классов в Visual Studio
    • Создание библиотеки классов с помощью .NET CLI
    • Модификаторы доступа
    • Свойства
    • Перегрузка методов
    • Статические члены и модификатор static
    • Установка пакетов Nuget
    • Константы, поля и структуры для чтения
    • Null и ссылочные типы
    • Null и значимые типы
    • Проверка на null, операторы ?. и ??
    • Псевдонимы типов и статический импорт
    • Наследование
    • Преобразование типов
    • Виртуальные методы и свойства
    • Скрытие методов и свойств
    • Различие переопределения и скрытия методов
    • Абстрактные классы
    • Класс System.Object и его методы
    • Обобщенные типы
    • Ограничения обобщений
    • Наследование обобщенных типов
    • Конструкция try..catch..finally
    • Блок catch и фильтры исключений
    • Типы исключений. Класс Exception
    • Генерация исключения и оператор throw
    • Создание классов исключений
    • Поиск блока catch при обработке исключений
    • Делегаты
    • Применение делегатов
    • Анонимные методы
    • Лямбды
    • События
    • Ковариантность и контравариантность делегатов
    • Делегаты Action, Predicate и Func
    • Замыкания
    • Определение интерфейсов
    • Применение интерфейсов
    • Явная реализация интерфейсов
    • Реализация интерфейсов в базовых и производных классах
    • Наследование интерфейсов
    • Интерфейсы в обобщениях
    • Копирование объектов. Интерфейс ICloneable
    • Сортировка объектов. Интерфейс IComparable
    • Ковариантность и контравариантность обобщенных интерфейсов
    • Определение операторов
    • Перегрузка операций преобразования типов
    • Индексаторы
    • Переменные-ссылки и возвращение ссылки
    • Методы расширения
    • Частичные классы и методы
    • Анонимные типы
    • Кортежи
    • Records
    • Паттерн типов
    • Паттерн свойств
    • Паттерны кортежей
    • Позиционный паттерн
    • Реляционный и логический паттерны
    • Паттерны списков
    • Список List
    • Двухсвязный список LinkedList
    • Очередь Queue
    • Стек Stack
    • Словарь Dictionary
    • Класс ObservableCollection
    • Интерфейсы IEnumerable и IEnumerator
    • Итераторы и оператор yield
    • Строки и класс System.String
    • Операции со строками
    • Форматирование и интерполяция строк
    • Класс StringBuilder
    • Регулярные выражения
    • Структура DateTime
    • Форматирование дат и времени
    • DateOnly и TimeOnly
    • Отложенная инициализация и тип Lazy
    • Математические вычисления и класс Math
    • Преобразование типов и класс Convert
    • Класс Array и массивы
    • Span
    • Индексы и диапазоны
    • Введение в многопоточность. Класс Thread
    • Создание потоков. Делегат ThreadStart
    • Потоки с параметрами и ParameterizedThreadStart
    • Синхронизация потоков
    • Мониторы
    • Класс AutoResetEvent
    • Мьютексы
    • Семафоры
    • Задачи и класс Task
    • Работа с классом Task
    • Задачи продолжения
    • Класс Parallel
    • Отмена задач и параллельных операций. CancellationToken
    • Асинхронные методы, async и await
    • Возвращение результата из асинхронного метода
    • Последовательное и параллельное выполнение. Task.WhenAll и Task.WhenAny
    • Обработка ошибок в асинхронных методах
    • Асинхронные стримы
    • Основы LINQ
    • Проекция данных
    • Фильтрация коллекции
    • Сортировка
    • Объединение, пересечение и разность коллекций
    • Агрегатные операции
    • Получение части коллекции
    • Группировка
    • Соединение коллекций
    • Проверка наличия и получение элементов
    • Отложенное и немедленное выполнение LINQ
    • Делегаты в запросах LINQ
    • Введение в Parallel LINQ. Метод AsParallel
    • Метод AsOrdered
    • Обработка ошибок и отмена параллельных операции
    • Введение в рефлексию. Класс System.Type
    • Применение рефлексии и исследование типов
    • Исследование методов и конструкторов с помощью рефлексии
    • Исследование полей и свойств с помощью рефлексии
    • Динамическая загрузка сборок и позднее связывание
    • Атрибуты в .NET
    • DLR в C#. Ключевое слово dynamic
    • DynamicObject и ExpandoObject
    • Использование IronPython в .NET
    • Сборщик мусора в C#
    • Финализируемые объекты. Метод Dispose
    • Конструкция using
    • Указатели
    • Указатели на структуры, члены классов и массивы
    • Работа с дисками
    • Работа с каталогами
    • Работа с файлами. Классы File и FileInfo
    • FileStream. Чтение и запись файла
    • Чтение и запись текстовых файлов. StreamReader и StreamWriter
    • Бинарные файлы. BinaryWriter и BinaryReader
    • Архивация и сжатие файлов
    • Сериализация в JSON. JsonSerializer
    • XML-Документы
    • Работа с XML с помощью System.Xml
    • Изменение XML-документа
    • XPath
    • Linq to Xml. Создание Xml-документа
    • Выборка элементов в LINQ to XML
    • Изменение документа в LINQ to XML
    • Сериализация в XML. XmlSerializer
    • Процессы
    • Домены приложений
    • AssemblyLoadContext и динамическая загрузка и выгрузка сборок
    • Native AOT
    • Нововведения в C# 11
    • Нововведения в C# 12

    Помощь сайту
    410011174743222
    Перевод на карту
    Номер карты:
    4048415020898850

    Контакты для связи: metanit22@mail.ru

    Copyright © metanit.com, 2023. Все права защищены.

    #5 - Циклы в Си и операторы в них

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

    Видеоурок

    В языке Си, как и в большинстве других языков, существует 3 вида циклов. Каждый из них выполняет одну и ту же роль, но записывается по-разному. Рассмотрим все три цикла.

    Цикл For

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

    for (int i = 0; i < 10; i++) printf("%d\n", i);

    В объявлении цикла записывается следующее: переменная цикла, её начальное значение и диапазон. В примере выше будут выведены числа от 0 до 10.

    Если в теле цикла всего одна строка кода, то фигурные скобки можно пропустить и не записывать их.

    Цикл While

    Суть цикла while не особо отличается от цикла for . Единственное отличие заключается в способе записи цикла. В while необходимо прописать лишь условие, а все остальные параметры записываются вне цикла:

    int i = 1; // Создание переменной while (i 

    Цикл Do While

    Цикл схож с циклом while по форме написания, но при этом работает немного по-другому. Цикл do..while будет выполнен один раз сто процентов, а дальше проверит условие и если оно верно, то цикл будет выполняться дальше:

    int x = 13; do < x--; printf("%d\n", i); >while (x > 10);

    Как видно из примера, цикл изначально неверный, но это не мешает ему сработать один раз.

    Операторы для работы в циклах

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

    • Оператор break - служит для выхода из цикла полностью;
    • Оператор continue - пропускает лишь одну итерацию и не выходит из цикла.
    Весь код будет доступен после подписки на проект!

    Задание к уроку

    Необходимо оформить подписку на проект, чтобы получить доступ ко всем домашним заданиям

    Большое задание по курсу

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

    Операторы цикла в языке Си

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

    Каждый цикл состоит из

    • блока проверки условия повторения цикла
    • тела цикла

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

    В языке Си следующие виды циклов:

    • while — цикл с предусловием;
    • do…while — цикл с постусловием;
    • for — параметрический цикл (цикл с заданным числом повторений).

    Цикл с предусловием while

    Общая форма записи

    while (Условие)
    БлокОпераций;
    >

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

    Пример на Си : Посчитать сумму чисел от 1 до введенного k

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() int k; // объявляем целую переменную key
    int i = 1;
    int sum = 0; // начальное значение суммы равно 0
    printf( "k = " );
    scanf( "%d" , &k); // вводим значение переменной k
    while (i sum = sum + i; // добавляем значение i к сумме
    i++; // увеличиваем i на 1
    >
    printf( "sum = %d\n" , sum); // вывод значения суммы
    getchar(); getchar();
    return 0;
    >

    Цикл while

    Результат выполнения

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

    Пример бесконечного цикла

    while (1)
    БлокОпераций;
    >

    while — цикл с предусловием, поэтому вполне возможно, что тело цикла не будет выполнено ни разу если в момент первой проверки проверяемое условие окажется ложным.

    Цикл while может не выполниться ни разу

    Например, если в приведенном выше коде программы ввести k=-1, то получим результат

    Цикл с постусловием do. while

    Общая форма записи

    do <
    БлокОпераций;
    > while (Условие);

    Цикл do. while — это цикл с постусловием, где истинность выражения, проверяющего Условие проверяется после выполнения Блока Операций , заключенного в фигурные скобки. Тело цикла выполняется до тех пор, пока выражение, проверяющее Условие , не станет ложным, то есть тело цикла с постусловием выполнится хотя бы один раз.

    Использовать цикл do. while лучше в тех случаях, когда должна быть выполнена хотя бы одна итерация, либо когда инициализация объектов, участвующих в проверке условия, происходит внутри тела цикла.

    Пример на Си . Проверка, что пользователь ввел число от 0 до 10

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    #include // для использования функции system()
    int main() int num; // объявляем целую переменную для числа
    system( "chcp 1251" ); // переходим на русский язык в консоли
    system( "cls" ); // очищаем экран
    do printf( "Введите число от 0 до 10: " ); // приглашение пользователю
    scanf( "%d" , &num); // ввод числа
    > while ((num < 0) || (num >10)); // повторяем цикл пока num10
    printf( "Вы ввели число %d" , num); // выводим введенное значение num - от 0 до 10
    getchar(); getchar();
    return 0;
    >

    Цикл do. while

    Результат выполнения:

    Параметрический цикл for

    Общая форма записи

    for (Инициализация; Условие; Модификация)
    БлокОпераций;
    >

    for — параметрический цикл (цикл с фиксированным числом повторений). Для организации такого цикла необходимо осуществить три операции:

    • Инициализация - присваивание параметру цикла начального значения;
    • Условие - проверка условия повторения цикла, чаще всего - сравнение величины параметра с некоторым граничным значением;
    • Модификация - изменение значения параметра для следующего прохождения тела цикла.

    Эти три операции записываются в скобках и разделяются точкой с запятой ; ;. Как правило, параметром цикла является целочисленная переменная.
    Инициализация параметра осуществляется только один раз — когда цикл for начинает выполняться.
    Проверка Условия повторения цикла осуществляется перед каждым возможным выполнением тела цикла. Когда выражение, проверяющее Условие становится ложным (равным нулю), цикл завершается. Модификация параметра осуществляется в конце каждого выполнения тела цикла. Параметр может как увеличиваться, так и уменьшаться.

    Пример на Си : Посчитать сумму чисел от 1 до введенного k

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() int k; // объявляем целую переменную key
    int sum = 0; // начальное значение суммы равно 0
    printf( "k = " );
    scanf( "%d" , &k); // вводим значение переменной k
    for ( int i=1; i sum = sum + i; // добавляем значение i к сумме
    >
    printf( "sum = %d\n" , sum); // вывод значения суммы
    getchar(); getchar();
    return 0;
    >

    Цикл while

    Результат выполнения

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() int k; // объявляем целую переменную key
    int sum = 0; // начальное значение суммы равно 0
    printf( "k = " );
    scanf( "%d" , &k); // вводим значение переменной k
    int i=1;
    for (; i sum = sum + i; // добавляем значение i к сумме
    >
    printf( "sum = %d\n" , sum); // вывод значения суммы
    getchar(); getchar();
    return 0;
    >

    Параметры, находящиеся в выражениях в заголовке цикла можно изменить при выполнении операции в теле цикла, например

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() int k; // объявляем целую переменную key
    int sum = 0; // начальное значение суммы равно 0
    printf( "k = " );
    scanf( "%d" , &k); // вводим значение переменной k
    for ( int i=1; i sum = sum + i; // добавляем значение i к сумме
    i++; // добавляем 1 к значению i

    >
    printf( "sum = %d\n" , sum); // вывод значения суммы
    getchar(); getchar();
    return 0;
    >

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() int k; // объявляем целую переменную key
    printf( "k = " );
    scanf( "%d" , &k); // вводим значение переменной k
    for ( int i=1, j=2; i < // (i от 1 до k с шагом 1) и (j от 2 с шагом 2)
    printf( "i = %d j = %d\n" , i, j); // выводим значения i и j
    >
    getchar(); getchar();
    return 0;
    >

    Цикл for

    Результат выполнения

    Вложенные циклы

    В Си допускаются вложенные циклы, то есть когда один цикл находится внутри другого:

    for (i = 0; i <
    for (j = 0; j ; // блок операций Цикла2
    >
    // блок операций Цикла1;
    >

    Пример : Вывести числа от 0 до 99, по 10 в каждой строке

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() for ( int i=0; i <
    for ( int j = 0; j < 10; j++) // цикл для единиц
    printf( "%2d " , i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
    >
    printf( "\n" ); // во внешнем цикле переводим строку
    >
    getchar(); // scanf() не использовался,
    return 0; // поэтому консоль можно удержать одним вызовом getchar()
    >

    Вложенные циклы: вывод чисел от 0 до 99

    Результат выполнения

    Рекомендации по выбору цикла

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

    Операторы прерывания и продолжения цикла break и continue

    В теле любого цикла можно использовать операторы прерывания цикла - break и продолжения цикла - continue .

    Оператор break позволяет выйти из цикла, не завершая его.
    Оператор continue позволяет пропустить часть операторов тела цикла и начать новую итерацию.

    Пример на Си : Вывести числа от 0 до 99 ниже главной диагонали

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() for ( int i=0; i <
    for ( int j = 0; j < 10; j++) // цикл для единиц
    if (j > i) // если число единиц больше числа десятков в числе
    break ; // выходим из вложенного цикла и переходим к новой строке
    printf( "%2d " , i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
    >
    printf( "\n" ); // во внешнем цикле переводим строку
    >
    getchar(); // scanf() не использовался,
    return 0; // поэтому консоль можно удержать одним вызовом getchar()
    >

    Оператор break

    Результат выполнения

    Пример на Си : Вывести числа от 0 до 99 исключая числа, оканчивающиеся на 5 или 8

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() for ( int i=0; i <
    for ( int j = 0; j < 10; j++) // цикл для единиц
    if ((j == 5) || (j == 8)) // если число единиц в числе равно 5 или 8,
    continue; // переходим к следующей итерации цикла
    printf( "%2d " , i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
    >
    printf( "\n" ); // во внешнем цикле переводим строку
    >
    getchar(); // scanf() не использовался,
    return 0; // поэтому консоль можно удержать одним вызовом getchar()
    >

    Оператор continue

    Результат выполнения

    При вложенных циклах действия операторов break и continue распространяется только на самую внутреннюю структуру, в которой они содержатся.

    Оператор безусловного перехода goto

    Общая форма записи

    goto Метка;
    . . .
    Метка : Операция;

    Выполнение оператора goto вызывает передачу управления в программе операции, помеченной Меткой . По сути Метка является идентификатором адреса операции, которой должно быть передано управление. Для отделения Метки от Операции используется двоеточие - : .
    Метка может располагаться в программе как до оператора goto , так и после него. Имена Меток образуются по тем же правилам, что и имена переменных.

    Пример на Си : Вывести все целые числа от 5 до 0.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main() int k = 5;
    M1: if (k < 0) // если kgoto M2; // переходим на метку M2 (выходим из программы)
    printf( "%d " , k); // выводим значение k
    k--; // уменьшаем k на 1
    goto M1; // переходим на метку M1 (повторяем операции выше)
    M2: getchar();
    return 0;
    >

    Оператор goto

    Результат выполнения

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

    Комментариев к записи: 26

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *