Циклы в языке си: Операторы цикла в языке Си : for, while, do…while

7.9 – Инструкции for

Добавлено 29 мая 2021 в 16:06

Безусловно, наиболее часто используемой инструкцией цикла в C++ является оператор for. Оператор for (также называемый циклом for) предпочтителен, когда у нас есть очевидная переменная цикла, потому что он позволяет нам легко и кратко определять, инициализировать, тестировать и изменять значение переменных цикла.

Начиная с C++11, существует два разных типа циклов for. В этом уроке мы рассмотрим классический оператор for, а новый оператор for на основе диапазона в следующем уроке (10.19 – Циклы for-each), как только рассмотрим некоторые другие необходимые темы, такие как массивы и итераторы.

Оператор for абстрактно выглядит довольно просто:

for (инструкция_инициализации; условие; конечное_выражение)
   инструкция;

Самый простой способ изначально понять, как работает оператор

for, – это преобразовать его в эквивалентный оператор while:

{// обратите внимание на блок здесь
    инструкция_инициализации; // используется для определения переменных,
                              // используемых в цикле
    while (условие)
    {
        инструкция;
        конечное_выражение; // используется для изменения переменной цикла перед
                            // повторным вычислением условия
    }
} // переменные, определенные внутри цикла, здесь выходят из области видимости

Вычисление операторов

for

Оператор for вычисляется в трех частях:

1. Сначала выполняется инструкция инициализации. Это происходит только один раз при запуске цикла. Инструкция инициализации обычно используется для определения и инициализации переменных. Эти переменные имеют «область видимости цикла», которая на самом деле является формой области видимости блока, где эти переменные существуют от точки определения до конца инструкции цикла. В нашем эквивалентном цикле
   while вы можете видеть, что инструкция инициализации находится внутри блока, содержащего цикл, поэтому переменные, определенные в инструкции инициализации, выходят за пределы области видимости, когда блок, содержащий цикл, заканчивается.
2. Во-вторых, для каждой итерации цикла вычисляется условие. Если оно истинно, инструкция выполняется. Если оно принимает значение false, цикл завершается, и выполнение продолжается со следующей инструкции за пределами цикла.
3. Наконец, после выполнения инструкции вычисляется конечное выражение. Обычно это выражение используется для увеличения или уменьшения переменных цикла, определенных в инструкции инициализации. После того, как конечное выражение было вычислено, выполнение возвращается ко второму шагу (и условие вычисляется снова).

Давайте посмотрим на пример цикла for и обсудим, как он работает:

#include <iostream>
 
int main()
{
    for (int count{ 1 }; count <= 10; ++count)
        std::cout << count << ' ';
 
    return 0;
}

Сначала мы объявляем переменную цикла с именем count и инициализируем ее значением 1.

Во-вторых, вычисляется count <= 10, и, поскольку count равно 1, условие вычисляется как true. Следовательно, выполняется инструкция, которая выводит 1 и пробел.

Наконец, вычисляется выражение ++count, которое увеличивает значение count до 2. Затем цикл возвращается ко второму шагу.

Теперь снова вычисляется count <= 10. Поскольку count имеет значение 2, условие вычисляет значение true, поэтому цикл повторяется снова.

Инструкция печатает 2 и пробел, и count увеличивается до 3. Цикл продолжает повторяться, пока в конечном итоге count не увеличится до 11, после чего count <= 10 вычисляется как false, и цикл завершается.

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

1 2 3 4 5 6 7 8 9 10

В качестве примера давайте преобразуем приведенный выше цикл for в эквивалентный цикл while:

#include <iostream>
 
int main()
{
    { // блок здесь обеспечивает область видимости блока для count
        int count{ 1 };     // наша инструкция инициализации
        while (count <= 10) // наше условие
        {
            std::cout << count << ' '; // наша инструкция
            ++count;                   // наше конечное выражение
        }
    }
}

Выглядит не так уж плохо, правда? Обратите внимание, что здесь необходимы внешние фигурные скобки, потому что count выходит за пределы области видимости, когда цикл заканчивается. exponent (base в степени exponent).

Это цикл for с простым увеличением счетчика на 1, с циклическим увеличением count от 0 до exponent (не включительно).

• Если exponent равен 0, цикл for будет выполняться 0 раз, и функция вернет 1.
• Если exponent равен 1, цикл for выполнится 1 раз, и функция вернет 1 * base.
• Если exponent равен 2, цикл for будет выполнен 2 раза, и функция вернет 1 * base * base
  .

Хотя большинство циклов for увеличивают переменную цикла на 1, мы также можем уменьшать ее:

#include <iostream>
 
int main()
{
    for (int count{ 9 }; count >= 0; --count)
        std::cout << count << ' ';
 
    return 0;
}

Эта программа напечатает следующий результат:

9 8 7 6 5 4 3 2 1 0

В качестве альтернативы мы можем с каждой итерацией изменять значение нашей переменной цикла более чем на 1:

#include <iostream>
 
int main()
{
    for (int count{ 9 }; count >= 0; count -= 2)
    std::cout << count << ' ';
 
    return 0;
}

Эта программа напечатает следующий результат:

9 7 5 3 1

Ошибки на единицу

Одна из самых больших проблем, с которыми сталкиваются новички в циклах for (и других циклах, в которых используются счетчики), – это ошибки «на единицу».

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

Например:

#include <iostream>
 
int main()
{
    // упс, мы использовали operator< вместо operator<=
    for (unsigned int count{ 1 }; count < 5; ++count)
    {
        std::cout << count << ' ';
    }
 
    return 0;
}

Эта программа должна печатать «1 2 3 4 5», но она печатает только «1 2 3 4», потому что мы использовали неправильный оператор отношения.

Хотя наиболее частой причиной этих ошибок является использование неправильного оператора отношения, иногда они могут возникать при использовании префиксного инкремента или префиксного декремента вместо постфиксного инкремента или постфиксного декремента, или наоборот.

Пропущенные выражения

Циклы for можно писать, опуская какие-либо или все инструкции или выражения. Например, в следующем примере мы опустим инструкцию инициализации и конечное выражение, оставив только условие:

#include <iostream>
 
int main()
{
    int count{ 0 };
    for ( ; count < 10; ) // нет инструкции инициализации и конечного выражения
    {
        std::cout << count << ' ';
        ++count;
    }
 
    return 0;
}

Этот цикл for дает следующий результат:

0 1 2 3 4 5 6 7 8 9

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

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

for (;;)
    инструкция;

Приведенный выше пример эквивалентен следующему коду:

while (true)
    инструкция;

Это может показаться немного неожиданным, поскольку вы, вероятно, ожидаете, что пропущенное условное выражение будет обрабатываться как ложное. Однако стандарт C++ явно (и непоследовательно) определяет, что пропущенное условное выражение в цикле for должно рассматриваться как истинное.

Мы рекомендуем полностью избегать этой формы цикла for и вместо нее использовать while (true).

Циклы

for с несколькими счетчиками

Хотя циклы for обычно выполняют итерацию только по одной переменной, иногда они должны работать с несколькими переменными. Для этого программист может определить несколько переменных в операторе инициализации, а в конечном выражении может использовать оператор запятой для изменения значений нескольких переменных:

#include <iostream>
 
int main()
{
    for (int x{ 0 }, y{ 9 }; x < 10; ++x, --y)
        std::cout << x << ' ' << y << '\n';
 
    return 0;
}

Этот цикл определяет и инициализирует две новые переменные: x и y. Он выполняет итерацию по x в диапазоне от 0 до 9, и после каждой итерации x увеличивается, а y уменьшается.

Эта программа дает следующий результат:

0 9
1 8
2 7
3 6
4 5
5 4
6 3
7 2
8 1
9 0

Это почти единственное место в C++, где определение нескольких переменных в одном инструкции и использование оператора запятой считается приемлемой практикой.

Лучшая практика

---

Определение нескольких переменных (в инструкции инициализации) и использование оператора запятой (в конечном выражении) внутри оператора for допустимо.

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

for

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

#include <iostream>
 
int main()
{
	for (char c{ 'a' }; c <= 'e'; ++c) // внешний цикл для букв
	{
		std::cout << c; // сначала печатаем нашу букву
		
		for (int i{ 0 }; i < 3; ++i)  // внутренний цикл для всех чисел
			std::cout << i;
 
		std::cout << '\n';
	}
 
	return 0;
}

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

a012
b012
c012
d012
e012

Вот еще несколько подробностей о том, что здесь происходит. Сначала выполняется внешний цикл, и char c инициализируется значением 'a'. Затем вычисляется c <= 'e', что верно, поэтому выполняется тело цикла. Поскольку c установлен в 'a', сначала выводится a. Затем полностью выполняется внутренний цикл (который выводит 0, 1 и 2). Затем печатается символ новой строки. Теперь тело внешнего цикла завершено, поэтому внешний цикл возвращается наверх, c увеличивается до 'b', и условие цикла повторно вычисляется. Поскольку условие цикла по-прежнему выполняется, начинается следующая итерация внешнего цикла. Это напечатает «b012\n«. И так далее.

Заключение

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

Операторы for идеально подходят, если у вас есть переменная-счетчик. Если у вас нет счетчика, вероятно, лучше выбрать оператор while.

Лучшая практика

---

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

Когда нет очевидной переменной цикла, предпочитайте использовать циклы while вместо циклов for.

Небольшой тест

Вопрос 1

Напишите цикл for, который печатает каждое четное число от 0 до 20.

Ответ

for (int count{ 0 }; count <= 20; count += 2)
    std::cout << count << '\n';

---

Вопрос 2

Напишите функцию с именем sumTo(), которая принимает целочисленный параметр с именем value и возвращает сумму всех чисел от 1 до value.

Например, sumTo(5) должна вернуть 15, что равно 1 + 2 + 3 + 4 + 5.

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

Ответ

int sumTo(int value)
{
    int total{ 0 };
    for (int count{ 1 }; count <= value; ++count)
        total += count;
 
    return total;
}

---

Вопрос 3

Что не так со следующим циклом for?

// Вывести все числа от 9 до 0
for (unsigned int count{ 9 }; count >= 0; --count)
    std::cout << count << ' ';

Ответ

Этот цикл for выполняется, пока count >= 0. Другими словами, он выполняется до тех пор, пока count не станет отрицательной. Однако, поскольку переменная count не имеет знака, она никогда не может стать отрицательной. Следовательно, этот цикл будет работать вечно (ха)! Как правило, рекомендуется избегать использования в циклах беззнаковых переменных без необходимости.

Оригинал статьи:

• 7.9 — For statements

Теги

C++ / CppforLearnCppwhileДля начинающихОбучениеПрограммированиеЦикл

Назад

Оглавление

Вперед

НОУ ИНТУИТ | Лекция | Управляющие операторы.

Структуры данных языка С

< Лекция 6 || Лекция 3: 12345

Аннотация: В данной лекции рассматриваются основные операторы языка: ветвления, циклы, передача управления, а также типы и структуры данных, унаследованные из языка С: указатели, массивы, строки, перечисления, структуры и объединения

Ключевые слова: теория программирования, выход, структурная схема, присваивание, логические операции, фигурные скобки, вычисление выражения, переключатель, целочисленный тип, switch, break, операторы цикла, цикла, тело цикла, целое число, итерация, ПО, безусловный переход, значение функции, составной оператор, оператор передачи управления, операторы перехода, continue, goto, throw, операторы, идентификатор, область видимости, функция, оператор безусловного перехода, вложенные циклы, время выполнения, деление, переполнение, обработка исключений, программа, значение, EPS, точность, указатель, типизированный указатель, равенство, неравенство, арифметическая операция, преобразование типов, параметр функции, адрес, сегменты, исполняемый код, int, double, битовые поля, переменная, константа, область действия, динамическая переменная, освобождение памяти, free, сложение, вычитание, инкремент, декремент, приведение типов, static_cast, void, операция присваивания, структура данных, разность, байт, приоритет операций, скалярное выражение, неименованная константа, ссылка, синоним, псевдоним, память, операции, передача параметров, ссылочный тип, инициализация, external, хранение данных, массив, компилятор, компиляция, входные данные, динамический массив, размерность массива, сумма элементов массива, размерность, FLOAT, динамические массивы, new, индекс, матрица, умножение, массив символов, нуль-символ, управляющая последовательность, длина, строковый, заголовочный файл, CSTRING, вывод, ввод/вывод, стандартная библиотека, подстрока, длина строки, пароль, копирование, именованная константа, инициализатор, список, описатели, элемент списка, структурный тип

Базовые конструкции структурного программирования

intuit.ru/2010/edi»>Презентацию к лекции Вы можете скачать здесь.

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

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

Ветвление задает выполнение либо одного, либо другого оператора в зависимости от выполнения какого-либо условия.

Цикл задает многократное выполнение оператора.

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

Рис. 3.1. Базовые конструкции структурного программирования

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

Оператор «выражение»

Любое выражение, завершающееся точкой с запятой, рассматривается как оператор, выполнение которого заключается в вычислении выражения. Частным случаем выражения является пустой оператор ; (он используется, когда по синтаксису оператор требуется, а по смыслу — нет). Примеры:

i++;			//выполняется операция инкремента
a *= b + c;		//выполняется умножение с присваиванием

Операторы ветвления

Условный оператор if

Условный оператор if используется для разветвления процесса вычислений на два направления. Структурная схема оператора приведена на рис. 3.1. Формат оператора:

if ( выражение ) оператор_1; [else оператор_2;]

Сначала вычисляется выражение, которое может иметь арифметический тип или тип указателя. Если оно не равно нулю, выполняется первый оператор, иначе — второй. После этого управление передается на оператор, следующий за условным. Одна из ветвей может отсутствовать.

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

Примеры:

if (a<0) b = 1;				// 1
if (a<b && (a>d || a==0)) b++; 
else {b *= a; a = 0;}	              	// 2
if (a<b) {if (a<c) m = a; else m = c;} 
else 	{if (b<c) m = b; else m = c;}	// 3

intuit.ru/2010/edi»>В примере 1 отсутствует ветвь else. Подобная конструкция называется «пропуск оператора», поскольку присваивание либо выполняется, либо пропускается в зависимости от выполнения условия.

Если требуется проверить несколько условий, их объединяют знаками логических операций. Например, выражение в примере 2 будет истинно в том случае, если выполнится одновременно условие a<b и одно из условий в скобках. Если опустить внутренние скобки, будет выполнено сначала логическое И, а потом — ИЛИ.

Оператор в примере 3 вычисляет наименьшее значение из трех переменных. Фигурные скобки в данном случае не обязательны.

Рис. 3.2. Мишень

Пример. Производится выстрел по мишени, изображенной на рис. 3.2. Определить количество очков.

#include <iostream>
using namespace std;
int main()
{float x, y; int kol;
 cout << "Введите координаты выстрела\n"; 
 cin >> x >> y;
 if ( x*x + y*y < 1 ) kol = 2; 
  else if ( x*x + y*y < 4 ) kol = 1; 
    else kol = 0;
 cout << "\n Очков: " << kol;
}

Оператор switch

intuit.ru/2010/edi»>Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений. Формат оператора:

switch ( выражение ){
	case константное_выражение_1: операторы_1;
	case константное_выражение_2: операторы 2;
	...
	case константное_выражение_n: операторы n;
	[default: операторы ;]}

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

Все константные выражения должны иметь разные значения, но быть одного и того же целочисленного типа. Несколько меток могут следовать подряд. Если совпадения не произошло, выполняются операторы, расположенные после слова default (а при его отсутствии управление передается следующему за switch оператору).

Пример (программа реализует простейший калькулятор на 4 действия):

#include <iostream>
using namespace std;
int main()
{
int a, b, res;	char op;
cout << "\nВведите 1й операнд : "; 
cin >> a;
cout << "\nВведите знак операции : "; 
cin >> op;
cout << "\nВведите 2й операнд : "; 
cin >> b;
bool f = true;
switch (op)
 {
 case '+': res = a + b; break;
 case '-': res = a - b; break;
 case '*': res = a * b; break;
 case '/': res = a / b; break;
 default : cout <<"\nНеизвестная операция"; 
		   f = false;
 }
if (f) cout << "\nРезультат : " << res;}

Выход из переключателя обычно выполняется с помощью операторов break или return.

Дальше >>

< Лекция 6 || Лекция 3: 12345

Цикл for в C | Как для Loop Woks в C с примерами?

При написании программ на языке C у нас может возникать необходимость много раз выполнять сопоставимую или точную группу инструкций, например, печать чисел от 1 до 100 на экране дисплея. Без использования циклов это может быть очень утомительно Кроме того, продукт сделает программу не распространяемой и никогда не понятной. Эта проблема была исправлена ​​с помощью цикла.

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

Бесконечные циклы

Бесконечные циклы могут быть сериями инструкций, которые можно выполнять вечно. Эти типы циклов возникают всякий раз, когда просто не предлагается условие завершения или, возможно, условие завершения, которое никогда не может быть выполнено (точно так же, как 1 == 2 и т. Д.), Или, может быть, иногда из-за ошибки во время выполнения. В старой системе бесконечные циклы приводили к тому, что вся система становилась безответственной; однако в современных операционных системах эти типы циклов обычно могут быть завершены конечным пользователем.

Петля состоит из 2 частей:

• Контрольная декларация
• Корпус петли

1. Объявление управления

Объявление управления проверяет конкретное условие, а после этого направляет обычные операторы, включенные в тело цикла.

2. Тело цикла

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

Синтаксис:

Синтаксис цикла for —

Вместе они определяют, следует ли выполнять оператор.

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

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

Блок-схема

                                                 

Как for Loop работает в C?

• Объявление инициализации выполняется только один раз.
• После этого условное выражение можно проверить. Если тестовое выражение ложно (0), цикл for завершается. Однако, если условное выражение истинно (отлично от нуля), выполняются коды в теле цикла for и обновляется выражение обновления.
• Этот метод повторяется до того, как проверочное выражение станет ложным.
• Цикл for обычно применяется, если известно количество итераций.
• Чтобы узнать больше об условном выражении (после проверки тестового выражения на ненулевое значение (истина) и 0 (ложь))

Примеры

Самый мощный оператор итерации, но потенциально также источник ошибок. Давайте сначала инициализируем переменную цикла.

Условие цикла оценивается, если его результат верен.

Выполняется тело цикла.

Если нет, выполнение продолжается после оператора for после выполнения тела.

Выполняется выражение, обновляющее переменную цикла, снова оценивается условие цикла и т. д., и это продолжается до тех пор, пока цикл не завершится. Конечно, этот цикл не выполнит свое тело, так как счет начинается с 10, а это не удовлетворяет условию.

Такие вещи легче увидеть с первого взгляда с помощью оператора for. Итак, давайте изменим инициализатор на 0 и проверим его, и вот наш счет от 0 до 9.как и ожидалось.

Вывод:

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

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

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

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

Здесь мы снова используем оператор break. Сначала мы познакомились с оператором switch.

Его также можно использовать для выхода из оператора цикла и запуска выполнения после цикла. Кстати, это работает так же хорошо с оператором while. Теперь это снова эквивалентно исходному оператору while и исходному оператору for с тремя частями оператора for, четко выстроенными в линию.

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

Давайте попробуем. И, конечно, снова от 0 до 9.

Заключение — для цикла в C

• Основные операторы предоставляются языком программирования C для выбора и итерации.
• Мы считали оператор if наиболее широко используемым оператором для выбора или управления потоком.
• Если какое-то выражение условия истинно, то выполняется соответствующий оператор или составной оператор. Если нет, выполнение продолжается со следующего оператора, если он есть.
Оператор
• For дает вам большой контроль над итерацией в более сжатом синтаксисе. Нет ничего, что вы не могли бы написать с помощью цикла while, но во многих случаях он более удобен и безопасен, поскольку вы можете включить объявление, которое не могут сделать другие операторы, по крайней мере, в C.
• Значение циклов в различных языках программирования огромно; они позволят нам свести к минимуму количество строк в программе, делая нашу программу более понятной и эффективной.

Рекомендуемые статьи

Это руководство по циклу for на языке C. Здесь мы обсуждаем введение и то, как цикл for работает на языке C, с примерами кода и выводом. Вы также можете просмотреть другие наши рекомендуемые статьи —

1. For Loop в Python 9.0018
2. Цикл while в программировании на C
3. Цикл выполнения в PHP
4. C# Пока Цикл

Цикл C for (с примерами)

Учебное пособие по C

Цикл for в C

Цикл for в C

share-outline Курс C++: Learn the Essentials 9000 3 Пратик Наранг

Бесплатно

Зачислено:

27958

Курс C++: Learn the Essentials

Prateek Narang

Бесплатно

Начать обучение

Обзор

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

Scope

В этой статье мы рассмотрим:

• Что такое цикл for в C?
• Для примеров циклов в C
• Несколько различных способов объявления и запуска циклов for в языке C.
• Как это соотносится с циклом while?

Знакомство с циклом for в языке C

Представьте себе, что компания поддерживает массив зарплат, который содержит зарплаты ее сотрудников, которые они должны получать каждый месяц. В праздничные месяцы с ноября по декабрь компания решает выдать каждому сотруднику премию в размере 15% от его заработной платы. Следовательно, компании придется создать новый массив updatedSalary, который будет содержать заработную плату для сотрудников, у которых обновлены бонусы.

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

Как это происходит, так это то, что выполняется цикл на массиве оклад , где каждый элемент массива добавляется, премия рассчитывается по формуле (0,15 * оклад), а затем прибавляется к исходному окладу. Затем эта сумма добавляется в новый массив updatedSalary , где она хранится в той же позиции, что и в зарплата

Теперь рассмотрим синтаксис цикла for:

синтаксис цикла for C

Синтаксис цикла for в c выглядит следующим образом:

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

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

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

Блок-схема цикла for в C

Ниже представлена ​​блок-схема цикла for в C.

for Loop Пример

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

ВЫВОД:

Формы цикла for

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

A) НЕТ ИНИЦИАЛИЗАЦИИ:

Инициализацию можно пропустить, как показано ниже:

B) НЕТ ОБНОВЛЕНИЯ:

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

C) НЕТ ИНИЦИАЛИЗАЦИИ И ОБНОВЛЕНИЯ :

Мы также можем избежать операторов инициализации и обновления!

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

Сравнение циклов for и while

Циклы for и while структурно похожи друг на друга, так как оба должны иметь тестовое условие, объявленное перед циклом, и программа проверяет тестовые условия каждый раз перед запуском петля еще раз. Хотя они выглядят так, будто делают одно и то же, у них совершенно разные варианты использования. Выполнение обоих циклов зависит от тестового выражения.

Основное различие между ними состоит в том, что цикл for выполняется 9 раз.0213 заданное количество раз , тогда как цикл while выполняется до тех пор, пока не будет выполнено условие . Это означает, что мы можем использовать циклы for, если знаем, сколько раз выполнять итерацию, и цикл while, когда не знаем.

В общем, используйте цикл while, если вы хотите, чтобы цикл прерывался в зависимости от чего-то другого, кроме количества его запусков.

Заключение:

• Циклы for в c используются для перебора последовательности.
• Он повторяется заданное количество раз и останавливается, как только выполняются условия.
• При отсутствии условия цикл будет повторяться бесконечно, пока не встретит команду прерывания.
Таким образом, циклы
• представляют собой набор инструкций, которые должны использоваться в определенной последовательности.
• Если структура цикла неверна, программа отобразит синтаксическую ошибку.