Ваше имя, возраст, рост и вес: Петр 17 178 67.5
При этом переменным name, age, rost, weight будут присвоены введенные значения.
В формат ввода, помимо спецификаций, могут входить и другие символы, причем:
· пробелы, символы табуляции \t и перехода на новую строку \n игнорируются;
· другие символы, если они имеются, должны совпадать с очередными непустыми символами, вводимыми с клавиатуры (символами входного потока), то есть они образуют шаблон, с которым должны совпадать вводимые данные:
scanf(“Возраст=%d, рост=%d, вес=%g, имя:%s”, &age, &rost, &weight, name);
входной поток имеет вид:
Возраст=17, рост=178, вес=67.5, имя:Петр
В этом случае переменные age, rost, weight, nameпримут соответствующие введенные значения.
Если перед спецификатором ввода стоит звездочка *, то поле, относящееся
к данному спецификатору в списке ввода, пропускается и вводимое значение игнорируется. Такая ситуация возникает тогда, когда вводятся значения из файла или с клавиатуры, но одной строкой (при этом они должны разделяться пробелами):
printf(“\nВаше имя, возраст, рост и вес: ”);
scanf(“%s%d%*d%*f”, name, &age, &rost, &weight);
Входной поток имеет вид:
Петр 17 178 67.5
В этом случае переменным будут присвоены следующие значения:
name=”Петр” age=17 rost=0 weight=0.000000
Внимание! Если переменная не инициализирована, то ее значение обнуляется.
Для ввода строк могут быть использованы две дополнительные спецификации:
%[символы] – вводимая строка должна содержать только символы, перечисленные в квадратных скобках без разделительных знаков. При появлении во вводимой строке неуказанного символа ввод строки заканчивается:
printf(“\nВведите строку:”);
scanf(“%[abceg]”, name);
Если вводимая строка имеет вид
Abcdefg
то переменная name примет значение abc
%[^символы] – вводимая строка ограничивается только символами, указанными в квадратных скобках:
printf(“\nВведите строку:”);
scanf(“%[^aed]”, name);
Если вводимая строка имеет вид
Abcdefg
то переменная name примет значение ae
Любая функция в Си возвращает какое-то значение. Поэтому функция scanf, помимо выполнения форматированного ввода, возвращает количество опознанных и присвоенных элементам списка ввода данных:
printf(“\nВаше имя, возраст, рост и вес: ”);
i=scanf(“%s%d%d%f”, name, &age, &rost, &weight);
Входной поток имеет вид:
Петр 17 178 67.5
При этом переменные name, age, rost, weight получат свои значения, и переменной i будет присвоено значение 4.
Внимание! Использование функции scanf для ввода строк имеет свои особенности.
Если вводимая строка состоит из нескольких слов, разделенных пробелами, то вводится только первое слово (до первого пробела):
char name[20];
printf(“\nВведите ваше имя и фамилию: ”);
scanf(“%s”, name);
Если входной поток имеет вид
Vasja Pupkin
то переменная name примет значение Vasja.
В таком случае для ввода строки лучше использовать функцию gets:
char name[20];
printf(“\nВведите ваше имя и фамилию: ”);
gets(name);
Если входной поток имеет вид
Vasja Pupkin
то переменная name примет значение Vasja Pupkin.
СТРУКТУРА ПРОГРАММЫ
Программа на Си состоит из одной или нескольких функций. Одна из них должна иметь имя main – головная – с нее начинается выполнение всей программы. Остальные функции вызываются из головной, а впоследствии – и из других функций
в порядке, определяемом алгоритмом решения задачи.
Все функции в Си имеют четко выраженную структуру – последовательность описаний и операторов, нарушать которую запрещено. Любая функция состоит из директив препроцессора, заголовка и блока.
Рассмотрим структуру головной функции.
В качестве директив препроцессора наиболее часто используются команды:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Заголовок головной функции имеет вид main(), после него ничего не ставится. Скобки обязательны, хотя в них, как правило, нет аргументов. Если головная функция ничего не возвращает в вызывающую программу (операционную систему), то перед ней стоит слово void:
Void main()
Во всех остальных случаях, как правило, головная программа имеет тип int .
В этом случае в конце программы необходимо поставить оператор return, после которого записать имя переменной или константу, возвращаемую головной программой в вызывающую (операционную систему):
return 0;
Блок программы включает описание данных, используемых в ней, и операторы языка. Блок заключается в фигурные скобки. После закрывающей фигурной скобки точка с запятой не ставится. Каждое описание и оператор программы заканчиваются точкой с запятой. Помимо описаний и операторов, в любое место программы можно вставить комментарий. В разделе описаний должны быть описаны все переменные и структуры данных, используемые в данной программе, с указанием их типов, имен и при необходимости размеров:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Int main()
{
int age, rost;
float weight;
char name[10];
printf(“\nВаше имя: ”);
scanf(“%s”, name);
printf(“\nВаш возраст: ”);
scanf(“%d”, &age);
printf(“\nВаш рост: ”);
scanf(“%d”, &rost);
printf(“\nВаш вес: ”);
scanf(“%f”, &weight);
printf(“\nВы ввели:”);
printf(“\nИмя - %s”, name);
printf(“\nВозраст - %d”, age);
printf(“\nРост - %d”, rost);
printf(“\nВес - %4.1f”, weight);
printf(“\n”);
return 0;
}
ДИРЕКТИВЫ ПРЕПРОЦЕССОРА
В любую функцию могут быть включены директивы (команды) препроцессора.
Препроцессор – это пакет программ для предварительной (до компиляции) обработки текста программы на Си. Препроцессор является мощным средством программиста, позволяющим облегчить написание и отладку программ, а также улучшить их читаемость.
Препроцессор позволяет:
- подключать к данной программе файлы с другими программами (функциями) или собирать одну программу из нескольких файлов,
- осуществлять подстановку имен,
- включать в программу макроопределения (макросы).
Управление работой препроцессора осуществляется директивами, дающими команду препроцессору на выполнение определенных действий. Обработанный препроцессором текст программы передается компилятору для перевода на машинный язык и далее – на сборку (компоновку) программы и ее выполнение.
Включение файлов
Программа на языке Си обычно состоит из нескольких функций, хранящихся в различных файлах на внешних носителях. Отдельная функция тоже может быть разбита на несколько кусков, каждый из которых может храниться в отдельном файле.
Директива включения файлов #include позволяет найти на внешнем носителе заданный файл и подключить его к головной программе или вызываемой функции. Так создается единый файл, в котором собрана вся программа.
Кроме того, директива включения файлов позволяет подключать к программе пользователя стандартные библиотеки Си, например библиотеку функций ввода-вывода, хранящуюся в файле stdio.h (standard input/output header file). Файлы с расширением имени .h называются заголовочными файлами. Они содержат описание переменных, функций и типов, используемых программистами, – аналог раздела INTERFACE в описании модулей Паскаля. Директивы включения таких файлов помещаются перед заголовками функций:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Заключение имени файла в угловые скобки < > говорит о том, что этот файл находится в системном каталоге Си, содержащем библиотеки стандартных программ.
Если имя файла заключено в кавычки “”, то он отыскивается по указанному пути:
#include “d:\user\my_file_1.cpp”
и вставляется в программу вместо этой директивы. Так программа собирается из отдельных кусков:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Int main()
{
#include “d:\user\my_file_1.cpp”
#include “d:\user\my_file_2.cpp”
#include “d:\user\my_file_3.cpp”
return 0;
}
Содержимое файла my_file_1.cpp:
int age, rost;
float weight;
char name[10];
Содержимое файла my_file_2.cpp:
printf(“\nВаше имя: ”);
scanf(“%s”, name);
printf(“\nВаш возраст: ”);
scanf(“%d”, &age);
printf(“\nВаш рост: ”);
scanf(“%d”, &rost);
printf(“\nВаш вес: ”);
scanf(“%f”, &weight);
Содержимое файла my_file_3.cpp:
printf(“\nВы ввели:”);
printf(“\nИмя - %s”, name);
printf(“\nВозраст - %d”, age);
printf(“\nРост - %d”, rost);
printf(“\nВес - %4.1f”, weight);
printf(“\n”);
После выполнения этих директив программа приобретает законченный вид:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Int main()
{
int age, rost;
float weight;
char name[10];
printf(“\nВаше имя: ”);
scanf(“%s”, name);
printf(“\nВаш возраст: ”);
scanf(“%d”, &age);
printf(“\nВаш рост: ”);
scanf(“%d”, &rost);
printf(“\nВаш вес: ”);
scanf(“%f”, &weight);
printf(“\nВы ввели:”);
printf(“\nИмя - %s”, name);
printf(“\nВозраст - %d”, age);
printf(“\nРост - %d”, rost);
printf(“\nВес - %4.1f”, weight);
printf(“\n”);
return 0;
}
После подключения указанных заголовочных файлов (.h) программа компилируется, компонуется и запускается на выполнение.
С системой программирования Си поставляются готовые включаемые файлы, содержащие стандартные библиотеки:
- stdio.h – ввода-вывода со стандартными функциями ввода-вывода getch, putch, gets,puts, scanf, printf,
- math.h – математических функций.
Подстановка имен
Подстановка имен или замена идентификаторов осуществляется директивой:
#define ИМЯ константа (имя)
Например:
#define MAX 100
Выполняя эту директиву, препроцессор в программе вместо переменной с именем MAX подставит число 100.
После слова define и имени необходимо оставить по пробелу. Так можно легко заменить в программе значения констант, поменяв их только в директиве #define.
Эту же директиву можно использовать и для замены одного имени на другое, более удобное или привычное:
#define AND &&
#define OR ||
Сейчас можно писать программу, используя в качестве логических операций более привычные слова AND и OR. Препроцессор заменит эти известные каждому программисту слова на операции && и ||, используемые в Си.
Директива #define может стоять в любом месте программы. Область ее действия – от места ее появления до конца программы или до директивы
#undef ИМЯ
Макросы
Директива #define позволяет осуществлять более сложные подстановки,
а именно определять функции, зависящие от нескольких аргументов, – макроопределения, или макросы:
#define SUMMA(x,y) ((x)+(y))
При этом каждое вхождение в текст программы выражения SUMMA(a,b) заменяется препроцессором на выражение ((a)+(b)), причем формальные аргументы макроса x и y заменяются соответственно на фактические аргументы (константы, переменные, элементы массивов, выражения) a и b, для которых и вычисляется значение макроса:
r=SUMMA(2,3);
В этом случае значение переменной r будет равно 5.
В общем виде эта директива записывается следующим образом:
#define ИМЯ (список аргументов) выражение
После слова define и перед выражением должны стоять пробелы. Подставляемое выражение и каждый формальный аргумент в нем необходимо взять вскобки. Если оно не помещается на одной строке, то его можно продолжить на следующих, используя слэш:
#define SUMMA(x,y) ((x)+\
(y))
Макросы похожи на функции, но их обработка не приводит к вызову функций со связанными с этим расходами по передаче аргументов, распределению памяти, возврату значения, что имеет место, когда мы работаем с функциями. Макросы обрабатываются на этапе препроцессирования, а не во время выполнения, и поэтому они могут сократить время выполнения программы. Кроме того, они работают с любыми типами аргументов, в то время как для функции нужно или выполнять приведение типов аргументов, или иметь несколько вариантов функции для различных типов аргументов.
Директиву можно использовать и для обращения к стандартным функциям:
#define VYVOD puts(“Programma studenta Vasi Pupkina”)
Выполняя эту директиву, препроцессор заменит в программе все встретившиеся имена VYVOD на функцию вывода puts(“Programma studenta Vasi Pupkina”).
По общепринятым правилам имена, используемые в директивах препроцессора, пишутся заглавными буквами, поэтому и в тексте программы они должны быть записаны так же.
АЛГОРИТМ И ЕГО СВОЙСТВА
Алгоритм – это последовательность предписаний (команд), точное выполнение которых приводит к решению поставленной задачи.
Правильно построенные алгоритмы должны обладать следующими свойствами:
дискретность – алгоритм разбит на отдельные элементарные этапы (шаги), возможность выполнения которых не вызывает сомнений;
однозначность – команды, входящие в алгоритм, должны быть точными и понятными, порядок их выполнения должен быть единственно возможным, любая неопределенность или двусмысленность недопустима;
детерминированность – повтор результатов при повторе исходных данных;
результативность – алгоритм должен приводить к результату за конечное число шагов;
массовость – алгоритм должен быть пригоден для решения всех задач данного класса.
Схемы алгоритмов
Любой алгоритм можно представить или записать тремя способами:
· словесным (вербальным) – с использованием слов и предложений;
· табличным (аналитическим) – с помощью формул и таблиц;
· графическим – с помощью рисунков, геометрических фигур и символов.
Самым наглядным из них является графический способ – представление алгоритма схемой.
Схема алгоритма – это графическое изображение его структуры, отдельных составных частей и взаимосвязей между ними.
Схема алгоритма представляет собой совокупность специальных символов (блоков), соединенных между собой стрелками, которые указывают последовательность его выполнения. Внутри каждого блока может быть записан его номер и краткое содержание исполняемых им функций (операций).
Правила выполнения схем алгоритмов устанавливает Единая система программной документации (ЕСПД), в которую входят:
ГОСТ 19002-80 «Схемы алгоритмов и программ. Правила выполнения»;
ГОСТ 19003-80 «Схемы алгоритмов и программ. Обозначения условные графические».
Перечень, наименование, обозначение и размеры наиболее употребляемых символов и отображаемых ими функций:
процесс – выполнение операции или группы операций, в результате которых изменяется значение, форма представления или расположение данных,
решение – выбор направления выполнения программы или алгоритма в зависимости от некоторых переменных условий,
модификация – выполнение операций, меняющих команды или группу команд, изменяющих программу,
предопределенный процесс – использование ранее созданных или отдельно описанных алгоритмов или программ,
данные – преобразование данных в форму, пригодную для обработки (ввод) или регистрации результатов обработки (вывод),
дисплей – вывод данных на дисплей (монитор),
терминатор – начало, конец, прерывание процесса обработки данных при выполнении программы,
линии потока – линии, связывающие символы схемы: линии,
идущие справа налево или снизу вверх, должны иметь стрелки,
комментарий – добавление описательных комментариев или пояснительных записей.
Пример записи алгоритма
Для построения удобных в работе схем алгоритмов необходимо руководствоваться следующими правилами:
ü каждая схема должна иметь точку начала и точку конца,
ü от точки начала блоки располагаются сверху вниз и слева направо,
ü направление линий потока сверху вниз и слева направо принимается за основное, и если линия потока не имеет излома, то стрелками ее можно не обозначать,
ü расстояние между параллельными линиями потока должно быть не менее
3 мм, между остальными линями схемы – не менее 5 мм,
ü количество входящих в блок линий потока не ограничивается, но выходить из него может только одна линия (исключение – блок решения, из которого всегда выходят две линии),
ü запись в блоках должна быть словесной или математической, а не в виде операторов конкретного алгоритмического языка: нужно показать, что делается в блоке, а не как это делается,
ü записи внутри блоков должны быть расположены так, чтобы их можно было читать слева направо и сверху вниз независимо от направления линий потока,
ü схема должна читаться без дополнительных пояснений автора,
ü используемые в некотором блоке переменные должны получать конкретные значения в предыдущих или в том же блоке,
ü входные и выходные блоки подпрограмм должны содержать перечень соответственно входных и выходных параметров,
ü блоки можно объединять в более крупные пунктирными линиями, при этом необходимо описать назначение объединенных блоков,
ü над левой частью блоков ставятся метки, которыми в программе будут помечены операторы, описанные в данном блоке, а в разрыве верхней левой линии ставится номер блока.
БАЗОВЫЕ СТРУКТУРЫ
Преимущество компьютеров и в то же время трудность их использования состоит в том, что они без труда выполняют операции, которые весьма трудоемки или практически невыполнимы людьми, и наоборот, действия, которые нам кажутся столь очевидными, что мы и не пытаемся их анализировать, зачастую становятся проблемой, когда предпринимается попытка их запрограммировать. Внешне заманчивая возможность предписать одним росчерком пера выполнение тысяч элементарных действий ставит трудную задачу понимания сложности, проблему, для решения которой необходимо вооружить себя определенными средствами. Такие средства алгоритмизации и программирования носят название базовых (управляющих) структур.
Как всякое автоматическое устройство, компьютер способен выполнять некоторое число элементарных операций: сложение, вычитание, сравнение, запись и чтение данных. Причем он обладает способностью самостоятельно управлять выполнением этих операций во времени. Если попытаться явно выразить возможности этого управления, то можно выделить три основные (базовые) управляющие структуры: цепочка (следование), ветвление, цикл. Эти комбинируемые по желанию структуры дают нам конструктор, позволяющий описать процесс вычислений произвольной сложности и полностью контролировать действия, предписываемые программой.
Практика разработки алгоритмов показывает, что в отдельных случаях одна и та же задача может быть успешно решена по алгоритмам, имеющим различную структуру. Главное требование к алгоритму заключается в том, чтобы он правильно решал поставленную задачу. Для удовлетворения этого требования алгоритм должен быть легким для понимания, простым для доказательства его правильности и удобным для модификации.
Опыт практической алгоритмизации привел к формированию особой методики организации алгоритмов, использование которой уменьшает вероятность ошибок
в процессе их разработки и записи, упрощает их понимание и модификацию. Эту методику алгоритмизации называют структурнымпрограммированием.
При структурном программировании алгоритм как бы собирается из трех базовых структур, каждая из которых имеет один вход и один выход – цепочек, ветвлений и циклов. С помощью этих структур можно построить алгоритмы любой сложности, подсоединяя одну структуру к другой и развивая алгоритм не только вширь, но и вглубь. Конструируемые по этой методике алгоритмы четки и понятны, легко поддаются проверке, так как состоят из ограниченного числа одинаково устроенных блоков.
Для использования методики структурного программирования при словесной записи алгоритмов необходимо, чтобы такая запись располагала специальными средствами, адекватно реализующими базовые структуры. Если таких средств в том или ином алгоритмическом языке нет, то для облегчения последующей работы по переводу алгоритма в программу (кодирования) необходимо отработать языковые шаблоны, эквивалентно представляющие базовые структуры.
Таким образом, в соответствии с принципами структурного программирования любой алгоритм можно представить, используя только три базовые структуры – цепочку, ветвление, цикл.
Цепочка
Самой простой базовой структурой является цепочка – последовательность операторов присваивания.
Цепочку можно представить следующей схемой:
Основное свойство цепочки – очередной оператор цепочки будет выполнен после выполнения всех предыдущих операторов, то есть все операторы цепочки выполняются последовательно друг за другом.
Алгоритм циклического обмена в этом случае будет выглядеть следующим образом:
Переменные a и b обмениваются своими значениями через переменную x.
По этому алгоритму можно написать последовательность операторов на Си:
x = a;
a = b;
b = x;
Ветвления
Одним из достоинств компьютеров является их способность делать выбор пути решения задачи в зависимости от выполнения заданных условий.
Выбор пути решения осуществляется в алгоритмических языках ветвлениями, которые могут быть представлены в двух формах:
· альтернатива,
· переключатель.
Альтернатива
Альтернатива является простейшей формой ветвлений. Она предполагает выбор одного из двух путей решения задачи, причем этот выбор зависит от выполнения заданных условий:
истина (да)ложь (нет)
Альтернативу можно описать словесно:
ЕСЛИ (условие)
ТО цепочка-1
ИНАЧЕ цепочка-2
В альтернативе может отсутствовать часть (ветвь) ИНАЧЕ, тогда она приобретает вид усеченной альтернативы:
истина (да) ложь (нет)
ЕСЛИ (условие)
ТО цепочка-1
В альтернативе в качестве условия используется логическое выражение, которое, как известно, может быть истинным или ложным.
Действие альтернативы:
1) проверяется выполнение условия,
2) если условие истинно, то выполняется следующая за ним цепочка-1,
а цепочка-2, если она имеется, не выполняется,
3) если условие ложно, то выполняется цепочка-2, если она имеется.
В Си альтернатива реализуется условным оператором:
If (условие)
оператор-1;
else оператор-2;
где условие – это любое логическое выражение (обязательно ставится в скобки).
В каждой ветке альтернативы может следовать только один оператор языка, причем перед else точка с запятой ставитсяобязательно.
Примеры
1. Определить значения переменной z после выполнения операторов:
x = 1;
z = 3;
if (x – z > 0) в данном случае условие ложно, поэтому
z = z – 1; будетвыполняться ветвь else, и, значит,
else z = z + 1; z = 4
2. 
Определить наибольшую из двух переменных a и b, присвоив ее значение переменной с:
данет
Словесное описание алгоритма:
ЕСЛИ (a > b)
ТО c = a
ИНАЧЕ c = b;
Реализуем этот алгоритм на Си:
if (a > b)
c = a;
else c = b;
3. Решить эту же задачу сокращенной альтернативой:
а)двумя сокращенными альтернативами:
if (a > b)
c = a;
if (b > a)
c = b;
б)одной сокращенной альтернативой:
c = b;
if (a > b)
c = a;
Реализация альтернативы усложняется, если в каждой ее ветви имеется не по одному оператору, а по цепочке операторов. В этом случае цепочки заключаются в фигурные скобки:
sin c, если c < 2,5
a =
cos c, если c ≥ 2,5
| c |, если c < 2,5
b = 1/c, если c ≥ 2,5
На Си:
if (c < 2.5) Внимание! Перед служебным словом
{ elseставится точка с запятой!
a=sin(c);
b=fabs(c);
}
Else
{
a=cos(c);
b=1.0/c;
}
Еще раз необходимо обратить внимание на то, что в Си после закрывающей фигурной скобки точка с запятой не ставится, а перед ней – обязательно.
В каждой ветви условного оператора if могут, в свою очередь, стоять новые операторы if , что дает возможность использовать вложение операторов if до любого уровня.
Примеры
1. Определить наибольшую из трех переменных x, y,z и присвоить ее значение переменной s:
а) с использованием полной альтернативы:
ЕСЛИ (x > y) if (x > y)
ТО ЕСЛИ (x > z) if (x > z)
ТО s = x s=x;
ИНАЧЕ s = z else s=z;
ИНАЧЕ ЕСЛИ (y > z) else if (y > z)
ТО s = y s=y;
ИНАЧЕ s = z; else s=z;
б) с использованием усеченной альтернативы: вариант 1
s = z; s = z;
ЕСЛИ (x > y) if (x > y)
ТО ЕСЛИ (x > z) if (x > z)
ТО s = x; s=x;
ЕСЛИ (y > x) if (y >x)
ТО ЕСЛИ (y > z) if (y > z)
ТО s = y; s=y;
вариант 2 – с использованием операции конъюнкции
s = z; s = z;
ЕСЛИ (x > y) & (x > z) if ((x > y) && (x > z))
ТО s = x; s=x;
ЕСЛИ (y > x) & (y > z) if ((y >x) && (y > z))
ТО s = y; s=y;
2. По заданной дате (день, месяц, год) определить день недели, приходящийся на нее:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Int main()
{
int c, y1, y2, kl, day, month, year;
printf(“\nВведите день: ”);
scanf(“%d”, &day);
printf(“\nВведите месяц: ”);
scanf(“%d”, &month);
printf(“\nВведите год: ”);
scanf(“%d”, &year);
kl=0;
c=0;
y1=year/100;
y2=year-y1*100;
if ((y2==0) && (y1%4==0))
c=1;
if ((y2!=0) && (y2%4)==0))
c=1;
if ((c==1) && (month==1) ||(month==2))
kl=1;
if ((c==0) && (month==1) || month==2))
kl=2;
c=ceil(365.25*y2) + ceil(30.56*month) + day + kl;
c %= 7;
c += 3;
if (c==1)
printf(“\nЭто понедельник”);
if (c==2)
printf(“\nЭто вторник”);
if (c==3)
printf(“\nЭто среда”);
if (c==4)
printf(“\nЭто четверг”);
if (c==5)
printf(“\nЭто пятница”);
if (c==6)
printf(“\nЭто суббота”);
if (c==7)
printf(“\nЭто воскресенье”);
return 0;
}
По принятому в Си соглашению, ветвь else всегда относится к ближайшему предшествующему ему незанятому if:
if (n>0)
if (m % n > 2)
m -= n;
else m += n;
else m %= n;
В данном случае ветвь else m += n относится к if (m % n > 2), а ветвь else m %= n относится к if (n > 0).
При переходе с Паскаля на Си программисты часто допускают ошибки при формировании условия в операторе if, путая две операции:
= присваивания и
== сравнения:
if (a==b)
printf(“\nЭти величины равны между собой”);
else printf(“\nЭти величины не равны между собой”);
Это правильное сравнение значений двух переменных.
Перепишем это сравнение с ошибкой (компилятором не определяется):
if (a=b)
printf(“\nЭти величины равны между собой”);
else printf(“\nЭти величины не равны между собой”);
В этом случае сначала переменной a будет присвоено значение переменной b, а потом будет проверено, какое именно значение присвоено. Если это значение отлично от нуля (неложь), то выведется сообщение: