if(<условие1>)
{
// блок, если условие1 истинное
}
else if(<условие2>)
{
// блок, если условие2 истинное, а первое ложное
}
...
else
{
// блок, если все проверки завершились неудачей
}
читать дальшеПо сути программа выполняется так: проверяется первое условие, если оно истинное, то выполняется блок, следующий прямо за ним. Если нет — проверяется следующее условие, коих может быть сколько угодно. Если ни одно условие не выполнилось, программа исполняет код в блоке после одинокого else. Всех дополнительных блоков с else может и не быть, если они не нужны. Пример:
if(D < 0)
{
// Если дискриминант меньше нуля, то корней нет
}
else if(D == 0)
{
// Если же a равно нулю (первое условие тут уже считается
// ложным - иначе бы даже до проверки (D == 0) бы не дошли.
// Есть одно решение квадратного уравнения
}
else
{
// Здесь можно быть уверенным, что D заведомо больше нуля и
// 2 корня есть.
}
В качестве логической переменной может выступать любое целое число. Ложь — когда число равно нулю, истина — когда не равно. В циклах это используется часто. Покажу ниже.Любые логические операторы (например, сравнения) на выходе дают результат выражения: 0(ложь) и 1(истина). Что можно без проблем использовать в обычных вычислениях. Но не стоит так делать из-за того, что это плохо читается.
В качестве логической переменной может выступать любое целое число. Ложь — когда число равно нулю, истина — когда не равно. В циклах это используется часто. Покажу ниже.Любые логические операторы (например, сравнения) на выходе дают результат выражения: 0(ложь) и 1(истина). Что можно без проблем использовать в обычных вычислениях. Но не стоит так делать из-за того, что это плохо читается.
Теперь можно посмотреть, какие условия бывают.
Пример:
| Условие | Описание |
| X | Условие выполнено, если число не равно нулю. |
| !X | Оператор НЕ, превращает ложь в правду и наоборот. Выполнится, когда число равно нулю. |
| X == Y | Выполняется, если числа равны друг другу. |
| X != Y | Выполняется, когда числа не равны друг другу. |
| X > Y | Выполняется, когда X больше Y. |
| X < Y | Выполняется, когда X меньше Y. |
| X >= Y | Выполняется, когда X больше или равно Y. |
| X <= Y | Выполняется, когда X меньше или равно Y. |
if(x > 5)
{
// Сюда попадём, только если x окажется больше пяти.
}
Условия можно комбинировать и проверять, так сказать, «пачками»:
Все аргументы в таких выражениях постарайтесь обёртывать в скобочки, если они сложнее одной сущности (то есть выражения). Вот примерно так:
Условия можно комбинировать и проверять, так сказать, «пачками»:
| Оператор | Описание |
| X && Y | Логическое И. Условие истинно, если оба аргумента истинны. |
| X || Y | Логическое ИЛИ. Условие истинно, если хотя бы один аргумент истинный. |
| !X | Логическое НЕ. Как я уже говорил, условие истинно, если аргумент ложен. |
if((X > 0) && (Y > 0))
{
// Сюда попадём, если X больше нуля и Y больше нуля.
}
Код аналогичен этому:
Код аналогичен этому:
if(X > 0)
{
if(Y > 0)
{
// Сюда попадём, если X больше нуля и Y больше нуля.
}
}
Ещё пример с ИЛИ:
Ещё пример с ИЛИ:
if((X < 0) || (X > 255))
{
// Сюда попадём, если X меньше нуля или X больше 255
}
Второй способ условного выполнения полезен при выборе измножества вариантов:
Второй способ условного выполнения полезен при выборе измножества вариантов:
switch(<условие>)
{
case <вариант1>:
// какой-то код
break;
// Этим словом показываем, что всё сделали и
// конструкцию покидаем
case <вариант2>:
// какой-то код
break;
...
default:
// если ни один вариант не подошёл
// Данной позиции может и не быть, если она не нужна.
}
Тут проверяются конкретные значения и ничего более:
Тут проверяются конкретные значения и ничего более:
// В переменной key хранится, допустим, код нажатой кнопки от 1 до 3.
switch(key)
{
case 1:
// Нажали первую кнопку
break;
case 2:
// Нажали вторую кнопку
break;
case 3:
// Нажали третью кнопку
break;
}
Достаточно полезная конструкция - куда как читабельнее, чем 100500 if-else if. Ладно, с этим пока закончим. Теперь циклы.
Первый тип циклов: for.
Достаточно полезная конструкция - куда как читабельнее, чем 100500 if-else if. Ладно, с этим пока закончим. Теперь циклы.
Первый тип циклов: for.
for(<выполняется перед циклом>;<условие продолжения>;<код после каждого блока перед проверкой>)
{
// Блок кода, который повторяется много раз
}
Думаю, мало кто понял, о чём тут речь, если не встречали конструкцию ранее.Пример. Есть переменная i, которую нам надо прогнать от 0 до 99 с шагом 1. Например, посчитать сумму всех этих чисел:
Думаю, мало кто понял, о чём тут речь, если не встречали конструкцию ранее.Пример. Есть переменная i, которую нам надо прогнать от 0 до 99 с шагом 1. Например, посчитать сумму всех этих чисел:
uint8_t i; // Счётчик
uint16_t sum; // Сумма
sum = 0; // Обнулим перед сложением.
// Перед циклом сделаем i равным 0 - начальному значению.
// i = 0 - вот тут.
for(i = 0; i < 100; i++)
{
// Сначала в каждой итерации цикла идёт проверка значения i < 100.
// Если проверка проваливается (получаем ложь), то
// цикл тут же заканчивается
// После чего идёт блок кода
sum += i;
// после итерации и перед очередной проверкой
// происходит изменение счётчика: i++
}
// Таким образом кодвнутри цикла выполнится при всех i от 0 до 99
Одно из или все эти три поля могут быть и пустыми. Например,конструкция вида
for(;
{
// Код, который будет выполняться вечно (условия выхода нет),
// если только изнутри не произойдёт насильного прерывания цикла.
}
Второй тип циклов: while.
Второй тип циклов: while.
while(<условие>)
{
// Блок кода
}
Цикл будет выполняться, пока условие истинно.
a = 50;
while(a--)
{
// Код будет выполняться, пока a не станет 0.
// Поясняю:
// Сначала происходит сравнение переменной a с 0.
// Если не равно - цикл выполнится.
// Вне зависимости от результата проверки сразу после неё
// a уменьшится на 1.
}
Бесконечный цикл здесь записывается так:
Бесконечный цикл здесь записывается так:
while(1)
{
// Единица, как мы помним, тождественна истине, как и
// любое ненулевое число
}
Третий тип циклов: do-while.В них проверка условия продолжения цикла осуществляется после блока кода, а таквсё то же самое.
Третий тип циклов: do-while.В них проверка условия продолжения цикла осуществляется после блока кода, а таквсё то же самое.
do
{
// Блок кода. Выполнится хотя бы один раз в любом случае.
} while(<условие>);
В циклах работают два специальных оператора: break и continue.
В циклах работают два специальных оператора: break и continue.
Оператор break тут же прерывает цикл. Вне зависимости от тип цикла, условийи чего угодно.
Оператор continue форсирует переход к следующей итерации цикла. То есть как бы пропускает весь код до завершающей скобочки цикла, после чего код выполняется в общем порядке.
for(i = 10; i > 0; i--)
{
if(i == 5) continue;
// Если i будет равно пяти, то весь последующий код будет пропущен
// Ну, не совсем весь, а только до концатекущего блока.
if(i == 2) break;
// Если i будет равно 2, то цикл будет с этого места прерван.
// Какой-то полезный или бесполезный код
}
И да, обращайте внимание на разные тонкости условий, могут они технически выполнится или нет.Например, из данного цикла код никогда не выйдет, несмотряна то, что условие выхода есть:
И да, обращайте внимание на разные тонкости условий, могут они технически выполнится или нет.Например, из данного цикла код никогда не выйдет, несмотряна то, что условие выхода есть:
for(uint8_t i = 0; i < 300; i++)
{
// По идее, цикл должен прекратиться, если i станет равным 300
// Но такого произойти не может, так как тип uint8_t может
// хранить числа только от 0 до 255! И сразу после 255 будет 0.
// И условие продолжения никогда не будет нарушено.
}
Или так:
Или так:
uint8_t i = 10;
while(i >= 0)
{
// Вроде бы всё в порядке, но цикл опять жени когда не закончится.
// Число i беззнаковое и никогда меньше нуля не станет.
i--;