Если после #if константное выражение принимает истинное значение, то код между #if и #endif компилируется, в противном случае код пропускается. Директива #endif используется для обозначения конца блока #if.
Стандартный вид #if следующий:
#if константное_выражение
последовательность операторов
#endif
Например:
/* простой пример с #if */
#include
#define MAX 100
int main(void)
#if MAX>99
printf(«Compiled for array greater than 99.n»);
#endif
return 0;
>
Данная программа выводит сообщение на экран, поскольку, как определено в программе, МАХ имеет значение больше 99. Данный пример демонстрирует очень важный момент: выражение, следующее зa #if, вычисляется на этапе компиляции, следовательно, оно должно содержать ранее определенные идентификаторы и константы, а не переменные.
Работа #else во многом похожа на работу оператора else — она предоставляет альтернативный вариант, если #if содержит ложное состояние. Предыдущий пример можно расширить следующим образом:
IF ELSE C# | КОНСТРУКЦИЯ ЛОГИЧЕСКОГО ВЫБОРА | ВЕТВЛЕНИЕ В C# | C# ОТ НОВИЧКА К ПРОФЕССИОНАЛУ | # 13
/* простой пример с #if / #else */
#include
#def ine MAX 10
int main(void)
# if MAX>99
printf(«Compiled for array greater than 99.n»);
#else
printf(«Compiled for small array.n»);
#endif
return 0;
>
В данном случае MAX определяется так, чтобы значение было меньше 99, в результате чего компилируется не код, соответствующий #if, а код, соответствующий #else. Следовательно, выводится сообщение «Compiled for small array».
Обратим внимание, что #else используется для обозначения конца блока #if и начала блока #else. Это делается потому, что может быть только один #endif, связанный c #if.
#elif означает «иначе если» и используется для построения лесенки if-else-if с целью определения различных опций компиляции. За #elif следует константное выражение. Если выражение истинно, то блок кода компилируется и остальные выражения не проверяются. В противном случае рассматривается следующий блок. Стандартный вид #elif следующий:
#if выражение
последовательность операторов
#elif выражение 1
последовательность операторов
#elif выражение 2
последовательность операторов
#elif выражение 3
последовательность операторов
#elif выражение 4
последовательность операторов
.
#elif выражение N
последовательность операторов
#endif
Например, следующий фрагмент использует значение ACTIVE_COUNTRY для определения денежного знака:
#define US 0
#define ENGLAND 1
#define FRANCE 2
#define ACTIVE_COUNTRY US
#if ACTIVE_COUNTRY==US
char currency[] = «dollar»;
#elif ACTIVE_COUNTRY==ENGLAND
char currency[] = «pound»;
#else
char currency[] = «franc»;
#endif
#if и #elif могут быть вложенными. Если это имеет место, то каждый #endif, #else или #elif ассоциируется с ближайшим #if или #elif. Например, следующее совершенно корректно:
#17. Условный оператор if. Конструкция if-else | Python для начинающих
#if МАХ>100
#if SERIAL_VERSION int port = 198;
#elif
int port = 200;
#endif
#else
char out_buffer[100] ;
#endif
В Borland С++ в операторе #if можно использовать оператор времени компиляции sizeof. Например, следующая программа определяет, компилируется программа для больших или маленьких массивов:
#if (sizeof(char *) == 2)
printf(«Program compiled for small array.»);
#else
printf(«Program compiled for large array.»);
#endif
Источник: www.c-cpp.ru
Операторы ветвления
В языке программирования C синтаксис оператора ветвления if-else выглядит так:
if (логич_выражение) выражение1; else выражение2;
Как и в других языках ветка else не является обязательной.
В языке С в простых логических выражениях используются следующие знаки операторов: >, =,
В случае если тело той или иной ветки состоит из нескольких выражений, разделяемых точкой с запятой, тело заключается в фигурные скобки:
if (логич_выражение) < выражение1; выражение2; … >else
В C можно использовать вложенные конструкции if-else. При этом рекомендуют вкладывать во внешнюю ветку else, а не if, т.к. это позволяет избегать неоднозначности толкования инструкции. Посмотрите на такую конструкцию:
if (…) if (…) …; else …; else if (…) …; else …;
Для более легкого восприятия человеком отступами подчеркнуто, что куда вложено. Однако для компилятора с языка C отступы никакой роли не играют, и принадлежность первой ветки else не очевидна. Ее можно было бы ошибочно отнести к первому if, в результате чего второе else было бы вообще неуместным, т.к. не относилось бы ни к какому if.
В данном случае такой ошибки не будет, т.к. компилятор руководствуется правилом: ветка else относится к ближайшему к ней сверху if, у которого еще нет ветки else. Именно поэтому здесь первое else относится ко второму if (т.к. оно к нему ближе), а второе else к первому if, т.к. второе if уже «покрыто» предыдущим else. Теперь посмотрите вот на такую конструкцию:
if (…) if (…) …; else if (…) …; else …;
Программист отступами показал, что он хочет, чтобы первое else относилось к внешнему if. Однако компилятор, руководствуясь правилом отнесения веток else, расценит программу вот так (если перевести на удобство чтения ее программистом):
if (…) if (…) …; else if (…) …; else …;
При этом программа будет делать не то, что хотел программист: если в выражении при первом if будет возвращаться ложь, то ни один else просто не сработает. Однако в таких сложных случаях есть выход — это использование фигурных скобок, даже если тело условной инструкции состоит всего из одного выражения:
if (…) < if (…) …; >else if (…) …; else …;
В таком случае программа будет восприниматься компилятором именно так, как задумал программист.
Чаще всего на практике используется подобная конструкция множественного ветвления:
if (…) < … >else if (…) < … >else if (…) < … >else
Здесь с точки зрения компилятора каждое else относится к предыдущему if, но выравнивание делается таким, как будто в Си есть условный оператор множественного ветвления. Результат работы конструкции таков, что выполняется хотя бы одна ветка. И как только она выполняется, вся конструкция завершает работу.
Условное выражение
В языке программирования C существует сокращенная запись инструкции if-else в виде условного выражения, которое относится к тернарным операторам. Результат такого выражения может быть присвоен переменной:
(логич_выражение) ? выражение1 : выражение2
Переводится это так. Если логич_выражение вернуло истину, то все выражение возвращает выражение1; если логич_выражение вернуло ложь, то все выражение возвращает выражение2. Например:
x = 12; y = 16; z = (x > y) ? x — 1 : y — 1;
Здесь z получит значение 15. Такое условное выражение бывает очень удобно, однако область его применения ограничена простейшими случаями ветвления, т. к. невозможно создавать сложные «тела» в такой конструкции.
Операторы И () и ИЛИ (||)
Как известно логическое выражение может быть сложным. Логические операторы И и ИЛИ в языке программирования C обозначаются соответственно парными знаками амперсанда () и вертикальной черты (||). Их приоритет меньше, чем у простых логических операторов, поэтому простые логические операции при их объединении в сложные логические выражения можно не заключать в скобки. Пример сложного логического выражения на языке C:
a > 100 b != 0
Проверьте и объясните, что выводит функция printf(), если ей передать простые или сложные логические выражения. Например:
printf(«%dn», a == b c d); printf(«%dn», c d);
Оператор switch
При организации множественного выбора, когда проверяется значение переменной на соответствие тому или иному значению, бывает удобно использовать не условный оператор if-else, а оператор переключения switch. Его синтаксис можно описать так:
switch (целочисленная_переменная)
В скобках после слова switch может стоять не только переменная, но и выражение, результат выполнения которого возвращает целое значение (может быть символ). Константы при case также могут быть результатом выполнения выражений. Константы можно группировать в одном case (например, case 12, 13, 18 ). Ветка default не обязательна.
При выполнении оператора switch, заданное значение в круглых скобках сравнивается с константами. Как только совпадение будет найдено, все последующие вложенные во все case операции начинают выполняться. Другими словами, выполняется не только кейс, где произошло совпадение, но и все нижележащие ветки case (и default тоже), константы которых не совпадают со значением при switch. Например, в результате выполнения вот такой программы:
int a = 1; switch (a) { case 0: printf(«%d «, 0); case 1: printf(«%d «, 1); case 2: printf(«%d «, 2); default: printf(«%d «, -1); } printf(«n»);
на экране будет выведено:
1 2 -1
, т. к. как только совпадение было обнаружено, все нижеследующие инструкции были выполнены.
Чтобы этого не происходило, в конце операций, принадлежащих определенному case, дописывают оператор break, который осуществляет принудительный выход из всей конструкции (в данном случае switch). Например:
int a=1; switch (a) { case 0: printf(«%dn», 0); break; case 1: printf(«%dn», 1); break; case 2: printf(«%dn», 2); break; default: printf(«%dn», -1); }
выведет только единицу, т. к. выполнение всей инструкции switch прервется после выполнения инструкции break при case 1.
Курс с решением части задач:
pdf-версия
Источник: younglinux.info
С if else примеры программ
Условные конструкции позволяют направить ход программы по одному из возможных путей в зависимости от условия. В языке Си есть несколько операторов, которые позволяют это сделать.
Оператор if
Оператор if проверяет истинность условия, и если оно истинно, выполняет блок инструкций. Этот оператор имеет следующую сокращенную форму:
if (условие) инструкция;
В качестве условия может выступать любое выражение, которое возвращает число. Если это выражение возвращает ненулевое значение (то есть выражение истинно), то выполняется последующая инструкция:
#include int main(void)
Здесь у нас две условных конструкции if . В качестве инструкции в обоих случаях выполняется функция printf. И в обоих случаях условие представляет просто число. В первом случае «условие» равно 1, то есть «истинно» (любое число, кроме 0, представляет истину). Поэтому на консоль будет выполняться функция printf , которая выведет на консоль строку «Hello C».
А во втором случае «условие» равно 0, то есть «не верно/ложно». Поэтому инструкция printf(«Hello World n») НЕ будет выполняться.
В приведенном выше примере в качестве условий выступали числа 1 или 0. Однако в реальности в качестве условий выступает результат некоторых выражений, обычно, операций сравнения или логических операций. Однако все они в конечном счете возвращают либо 0 (условие не верно) или ненулевое значение (условие верно). Используем операции сравнения:
#include int main(void)
Здесь также используются две условных конструкции if. В первом случае n == 20 условие не верно, оно возвращает 0, так как значение переменной n не равно 20, поэтому поэтому последующая инструкция printf(«n = 20 n») не будет выполняться.
А во втором случае операция сравнения n == 10 возвратит 1, так как условие истинно, поэтому будет выполняться инструкция printf(«n = 10 n») .
Если в конструкции if необходимо выполнить не одну, а несколько инструкций, то эти инструкции оформляются в блок кода с помощью фигурных скобок:
#include int main(void) < int x = 60; if(x >50) < printf(«if statement n»); printf(«x is greater than 50 n»); >return 0; >
Здесь проверяем, больше ли переменная х чем 50. И если это условие истинно, выполняем последующий блок из двух инструкций
Условия могут более сложные:
#include int main(void) < int x = 50; int y = 60; if (x >20 y < 100) < printf(«the condition is truen»); >return 0; >
Здесь проверяем больше ли значение переменно х чем 20 и меньше ли значение переменной y чем 100. Поскольку здесь два условия соединяются операцией , то общее условие будет истинно, если одновременно верны оба условия.
Выражение else
Но что, если мы хотим определить две пары действий: одни выполняются, если условие истинно, а другие, если условие ложно? В этом случае можно использовать другую форму конструкции if — if..else :
if(условие) инструкция_1 else инструкция_2
После оператора else мы можем определить набор инструкций, которые выполняются, если выражение_условия ложно, то есть возвращает 0. То есть если условие истинно, выполнится инструкция после оператора if , а если это выражение ложно, то выполняется инструкция после оператора else .
int x = 60; if(x > 60) printf(«x is greater than 60 n»); else printf(«x is less or equal 60 n»);
Однако в данном случае у нас есть три условия: переменная x может быть больше 60, меньше 60 и равна 60. Для проверки альтернативных условий мы можем вводить выражения else if :
int x = 60; if(x > 60) printf(«x is greater than 60 n»); else if (x < 60) printf(«x is less than 60 n»); else printf(«x is equal 60 n»);
То есть в данном случае мы получаем три ветки развития событий в программе.
И также если после операторов должен идти набор инструкций, то эти инструкции оформляются в блок кода:
#include int main(void) < int x = 60; if(x >60) < printf(«if statement n»); printf(«x is greater than 60 n»); >else if (x < 60) < printf(«else if statement n»); printf(«x is less than 60 n»); >else < printf(«else statement n»); printf(«x is equal 60 n»); >return 0; >
Конструкция switch
Другую форму организации ветвления программ представляет конструкция switch. case . Она имеет следующую форму:
switch(выражение)
После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями после оператора сase . И если совпадение будет найдено, то будет выполняться данный блок сase .
В качестве констант после оператора case могут выступать значения типов char, int и unsigned
В конце конструкции switch может стоять блок default . Он необязателен и выполняется в том случае, если ни одна совпадения в блоках case не было найдено. Например, сравним значение переменной с набором значений:
#include int main(void) < int x = 2; switch(x) < case 1: printf(«x = 1 n»); break; case 2: printf(«x = 2 n»); break; case 3: printf(«x = 3 n»); break; default: printf(«x is undefined n»); break; >return 0; >
Здесь в качестве сравниваемого выражения выступает переменная x . Ее значение последовательно сравнивается со значениями после операторов case :
- сначала программа переходит к выражению case 1 . Но переменная x не равна 1, поэтому выполнение переходит к следующему оператору case.
- программа переходит к выражению case 2 . Поскольку переменная x равна 2, то выполняются инструкции данного оператора case:
case 2: printf(«x = 2 n»); break;
Тернарный оператор
Тернарный оператор ?: позволяет сократить определение простейших условных конструкций if и имеет следующую форму:
[первый операнд — условие] ? [второй операнд] : [третий операнд]
Оператор использует сразу три операнда. В зависимости от условия тернарный оператор возвращает второй или третий операнд: если условие равно 1 (то есть истинно), то возвращается второй операнд; если условие равно 0 (то есть ложно), то третий. Например:
#include int main(void) < int x=5; int y=2; int z = x >y ? x-y : x+y; printf(«z = %d», z); // z = 3 return 0; >
Здесь результатом тернарной операции является переменная z. Она имеет следующие операнды:
Источник: metanit.com