|
МПС
Язык
программирования МП – СИ (Лекция)
ПЛАН ЛЕКЦИИ 1. Алфавит языка СИ 2. Константы языка СИ 3. Формат определения переменной 4. Операции языка СИ 5. Структура программы на языке
СИ 6. Типы данных и их объявление 7. Разделители 8. Пример программы на языке СИ 1. Алфавит языка СИ 1. Прописные и строчные буквы
латинского алфавита; 2. Цифры от 0 до 9; 3. Спецзнаки (-, /,
., [], (), +, -) и др.; 4. В комментариях, строках и
символьных константах могут использоваться русские буквы. Комментарий формируется как последовательность
знаков ограниченных слева символами /*, а справа */. Комментарий может
отделяться слева символом // (в этом случае комментарий может быть записан
только в одну строку). Пример: /* Курсивом я пишу комментарий к
программе в Си он может быть написан в несколько строк */ // или в одну строку, после двух
черточек. Курсив взят условно, для лучшей усвояемости. // Курсив взят условно, для
лучшей усвояемости. Идентификатор – это
последовательность букв, цифр и символов подчеркивания, которые начинаются с
буквы или символа подчеркивания. Прописные и строчные буквы
различаются идентификаторами,
обозначающими служебные слова, константы, строковые константы, знаки операций,
знаки пунктуации. Служебные слова – это
зарезервированные в языке идентификаторы, которые нельзя выбирать в качестве
имен переменных и констант. Примеры служебных слов: - double - goto - void 2. Константы языка СИ Символьные
константы Для изображения отдельных знаков,
имеющих индивидуальные внутренние коды, используются символьные константы. Для
изображения знаков и их внутренних кодов используются таблицы ASCII. В этой таблице под каждый символ
отводится 1 байт информации, т.е. с ее помощью мы можем записать только 256
символов. Первая половина таблицы является стандартной и содержит символы
строчных и прописных букв латинского языка, цифры десятичной системы исчисления
и нескольких специальных символов. 2-ая половина ASCII таблицы содержит символы национального
алфавита и другие спецсимволы. Символьные константы изображаются
с помощью ограничивающих одинарных апострофов: Ох, О, Оb, десятичные цифры записываются без
префиксов. Пример №1 ·
в десятичной форме - 1234 ·
в двоичной форме с префиксом 0b так: 0b101001 ·
в шестнадцатеричной форме с префиксом 0x так:
0x5А ·
в восьмеричной форме с префиксом 0 так:
0775 Для перевода чисел из одного вида в другой можно использовать калькулятор Windows (в
инженерном виде). Целые
константы. Бывают десятичные, 16-ричные,
8-ричные. Десятичные цифры записываются без префиксов, 16-ричные константы
имеют префикс ОХ. Префикс – символьная запись, показывающая основание системы
счисления константы, 8-ричная константа имеет префикс О, 2-ичная константа
имеет префикс Оb. Под константы выделяется 2 байта
или 4 байта. Двухбайтные константы имеют тип int. Этот тип бывает знаковый и без знаковый (соответственно, signed int, unsigned int) просто int – знаковый тип. Четырехбайтные константы имеют
тип long. Этот тип
бывает знаковый и без знаковый. Вещественные константы Эти константы, представляют в
памяти процессора в форме с плавающей точкой. Каждая вещественная константа
состоит из следующих частей: ·
целая часть, ·
десятичная точка, ·
дробная часть, ·
признак показателя «е» или «Е», ·
показатель десятичной степени. Числа с плавающей точкой имеют в записи эту точку и какое-либо число
после этой точки. Пример № 1 61.234, 73.0 или .786 или могут иметь в конце символ «F»
вот так: 61.234F Константы
перечисляемого типа. Вводятся с помощью перечисления enum. Enum - служебное слово, вводящее
перечисление идентификатором. Используя запятые, определяют
значения константы. Например: Enum (one=1, two, three). Если в списке константы нет ни
одного числового значения, то значения констант начинается с О и увеличиваются
на 1 слева направо. Строковые
константы. Определяются как
последовательность символов, заключенных в двойные кавычки. Переменные являются объектами –
именованной областью памяти. Для задания этой области памяти необходимо знать
тип переменной, так как от этого зависит объем выделенной памяти. 3. Формат определения переменной Формат определения переменной
состоит из двух частей, разделенных пробелом: 1) тип; 2) список имен
переменных. Существуют следующие целочисленные
типы. Char – целый тип длиной не менее 8 бит. Short int – короткий, целый 1 байт Int – целый 2 байт Long – 4 байта Каждый из целочисленных типов
может быть определен как знаковый, т.е. впереди типа добавляется signed либо как без знаковый
- unsigned. Если тип знаковости не уточнен,
по умолчанию получается тип signed
– знаковый. Существует следующие вещественные
типы переменных и констант. Float - вещественный тип одинарной точности,
т.е. 7 значащих цифр в десятичном представлении. Double – двойной точности, т.е. 14
значащих цифр в десятичном представлении. Long double – максимальной
точности, , т.е. 28 значащих цифр в десятичном представлении. Инициализация переменных
происходит следующим образом: Тип список имен переменных =
значение переменных. Для инициализации констант, кроме
слова enum используются
следующая запись: Const тип список имен констант =
значение констант; Еще одну возможность обеспечивает
препроцессорная директива (команда для компилятора): # define имя константы значение константы. Для того, чтобы использовать
директиву define,
которая вводит в нашу программу именованные константы, записанные через служебные слова, используют еще раньше этой директивы директиву .include: # include < limits.h > стандартный файл с расширением H. Файл с расширением h содержит именованные
константы. 4. Операции языка СИ Многие
операции обозначаются символами, которые по-разному интерпретируются в
зависимости от контекста. Например, бинарная операция & - операция
получения адреса. Бинарная
операция использует два операнда, а унарная – один операнд. Большинство
операций языка Си совпадают с операциями языка ассемблер. 4.1. Унарные (однооперандные) операции 1. & - операция
получения адреса операнда. 2. * - операция обращения по
адресу, или операция разыменования, т.е. р = *а доступна по адресу к объекту на
который указывает операнд. 3. − - изменяет знак
арифметического операнда, а если операнд без знаковый, то результатом операции
является величина 2n,
где n – число бит,
выделяемое под данную переменную. 4. ~ - поразрядное
инвертирование внутреннего двойного кода
целочисленного аргумента, или побитовое отрицание. 5. ! – это логическое отрицание
значения операнда, результатом является ноль, если операнд ненулевой и результатом
является единица, если операнд нулевой. Пример №1: ! 0 =1 ! 5=1 ! 100=0 ! (-90)=0 6. ++ - увеличение на 1 операнда,
имеет две формы: ·
префиксная операция: увеличение значения
операнда на 1 до его использования, ·
постфиксная операция: увеличение значения
операнда на 1 после его использования. 7. -- - уменьшение на 1 (декремент),
также имеет две формы: ·
префиксная, ·
постфиксная. Операндами для обоих операций не
может быть константа и производное выражение (++5 ; ++(j+k)). Операндами этих операций должны быть модифицируемые
именные переменные 8. sizeof – операция вычисления размера в
байтах для операнда. Имеет две формы: ·
sizeof
выражение (р.а или р+а или ...) ·
sizeof
тип 4.2. Бинарные (двухоперандные) операции 1.
Арифметические операции в Си x + y – операция «сложение» x
- y – операция « вычитание» x * y – операция « умножение» x / y – операция « деление». Если
числа целые, то результат - целое число с отброшенной дробной частью - не округленное! Т.е., если в
результате деления на калькуляторе получается 6.23411 или 6.94, то результат
будет просто целое число 6 - запомните! Если числа с плавающей точкой, то
есть float или double и записываются с точкой и числом после точки, то и
результат будет число с плавающей точкой . x % y – операция «вычисления
остатка от деления нацело». Примеры: 5 / 2 – дает 2 5 %
2 – дает 1 2. Операция сдвига: определены
только для целочисленных операндов: << - операция сдвиг влево
битового представления значения левого целочисленного операнда на количество
разрядов, равное значению правого целочисленного операнда. 3. Поразрядная операция: ^ - операция «поразрядное сложение
по модулю два» (исключающее ИЛИ) битовых представлений значений целочисленных
операндов. 4. Операции отношений или
сравнений. Используются для сравнения
переменных, чисел (констант) и выражений. x < y – операция «x меньше y»
x > y – операция «больше» x <= y – операция «меньше или равно» x >= y – операция «больше или равно» x == y – операция «равно» x != y – операция «не равно». Результат выполнения этих
операций: "истина" это
"1" (точнее "не ноль") "ложно" это
"0 Значения, хранимые в переменных
(в регистрах) х и у, НЕ изменяются! Берутся (считываются)
значения хранящиеся (или содержащиеся) в переменных и сравниваются. 5. Логические операции: || - операция "ИЛИ" -
только "ложь" и "ложь" дают «ложь». Дизъюнкция (ИЛИ) арифметических
операндов. Пример: у= 5||1, у=1; у=5||0, у=1. && -
операция «конъюнкции» (И) арифметических операндов или отношений. Результат
целочисленный: О или 1."И" - только "истина" и
"истина" дают "истина". Пример №2: р = 5&&4 => р = 1 (1) (1) р = 5&&0 => р = 0 (1) (0) ! – операция "НЕ" -
логическое отрицание Правило - в Си считается: "Ложь" (False) только
ноль. "Истина"(True)- не ноль
или так: (!0) */ ! (истина) – дает
"ложь" ! (ложь) – дает
"истина" В результате логической операции
вы получаете НЕ ЧИСЛО, а логическое значение "истина" или
"ложь". Для логических операций
&& и || берутся результаты выражений слева и справа от
знака операции, преобразованные в
"истину" или "ложь", и определяется логический результат
операции. Компилятор результат
"истина" превращает в 1, а не в любое отличное от 0 число. Совет: Используйте скобки: ( () + ( () * () ) ), чтобы точно знать порядок выполнения операций программой! Логические операции могут
объединять несколько проверяемых условий. Например: if ((выражение1)&&((выражение2)||(выражение3)))
{ /* Код программы здесь будет
выполняться если: Выражение1 "Истина" (значит не ноль) и хотя бы
одно из выражений 2 и 3 тоже "Истина" (значит не ноль). */ }; 6. Операция присваивания. Чтобы поместить число в переменную (в
регистр) в Си, есть оператор присваивания это знак =, называемый в
математике "равно". = в Си означает
вычислить результат того, что справа от оператора присваивания и поместить
этот результат в переменную находящуюся левее
оператора присваивания. PORTB = PINB + 34; Эта строчка на Си означает: взять
(прочитать, считать) значение переменной (регистра) PINB, затем прибавить к
нему число 34 и поместить результат в переменную PORTB Пример
№3: 1.
Строка, где переменная стоит слева от =, но через знак &: PORTB & = 0x23; На Си означает - прочитать
содержимое переменной PORTB,
затем выполнить "поразрядное (побитное) логическое И" между
прочитанным значением и числом 0x23
и поместить (записать, присвоить) результат в переменную PORTB. Пример №4 2. Строка, где переменная стоит непосредственно слева от = PORTB = 0x23; на Си означает – не читая содержимое переменной PORTB присвоить ей значение 0x23. Вместо & "И" (AND - только 1 и 1 дают 1) могут быть и
другие побитные логические операции: | "ИЛИ" (OR только 0 и 0 дают 0). Поразрядная
дизъюнкция (ИЛИ) битовых представлений значений целочисленных операндов; ^ "иключающее ИЛИ" (XOR изменить бит напротив
"1"). Поразрядная (исключение ИЛИ) битовых представлений
значений целочисленных операндов; ~ "инвертирование битов" (изменить биты регистра). С
оператором присваивания используются следующие сокращения: Табл. 2 Сокращения, используемые с оператором присваивания
Пример №5: 10010 | 1001111 – операция "ИЛИ" -
только 0 и 0 дают 0 (англ. название OR ) 1011111 – это результат, только биты под номером 5 в обоих числах были
нули 10010 & 1001111 –
операция "И" - только 1 и 1 дают 1 (англ. название AND) 10 – это результат – только биты под номером 2 в
обоих числах были единицами. 10010 ^ 1001111 "исключающее ИЛИ" – сложение
по модулю два ( англ. название XOR). 1011101 – это результат. ~ 1001111 – поразрядное инвертирование , биты равные "1" станут
"0" и наоборот. 110000 – это результат. *= присваивание после умножения Пример: р*=2 -> р=p*2 /= присваивание после деления Пример №6: р/=2,2-d -> р=p/2,2-d %= - (присваивание после деления
по модулю); Пример №7: N%=3 -> N =N%3 += присваивание после
суммирования, -= присваивание после вычитания, <= присваивание после сдвига
раз,рядов влево, >>= присваивание после
сдвига разрядов вправо, &= присваивание после
поразрядной конъюнкции (И), |= присваивание после поразрядной
дизъюнкции (ИЛИ), ^= присваивание после
поразрядного исключающего ИЛИ. Результатом поразрядных
(побитных) логических операций: & | ^ ~, является число, которое
может быть интерпретировано компилятором как "истина", если оно не
ноль и "ложно", если число ноль. Есть в Си операции которые изменяют значение переменной и без
оператора присваивания: PORTA++; Эта строчка на Си означает: взять значение переменной
PORTA добавить к ней 1 и записать результат обратно в PORTA (говорят: Инкрементировать регистр PORTA). PORTC--; Эта строчка на Си означает обратное действие! (Декрементировать - вычесть 1 из
значения регистра PORTC). Инкремент и декремент
удобно использовать для изменения значения различных переменных счетчиков.
Важно, помнить, что они имеют очень низкий приоритет – поэтому, чтобы быть уверенными
в порядке выполнения желательно писать их отдельной строчкой программы! В конце выражения или конструкции
в программе на Си ставят точку с запятой. Длинные выражения можно писать в
несколько строк. Когда инкремент или декремент
используется в выражении, то становится важным место, где стоят два знака + или
-, перед переменной или после переменной: a=4; b=7; a = b++; Эта строчка на Си означает: взять значение переменной b присвоить его переменной a, затем добавить 1 к переменной b и сохранить результат в b. В результате a будет содержать число 7, а b будет содержать число 8. a=4; b=7; a = ++b; Эта строчка на Си означает: взять значение переменной b затем добавить к нему 1 и
сохранить результат в b, и этот
же результат присвоить a. Теперь a будет содержать число 8 и b будет содержать число 8. 4.3. Условные и
циклические операторы if(){}else{};
идеальная конструкция, если вам нужно выполнить какую-то часть программы при
наличии каких либо условий: if (выражение) { /*
делать этот код, если выражение "истина"
- т.е. результат его вычисления не ноль */ } else { /* делать этот код, если выражение "ложь" - т.е. результат его вычисления равен
нулю */ }; } else { - это не обязательный элемент конструкции: if (выражение) { /*
делать этот код, если выражение
"истина" - т.е. результат его вычисления не ноль */ }; while(){}; - это условный
цикл - используйте если вам нужно выполнять какой-то код программы пока
выполняется (существует, справедливо, не ноль) некоторое условие: while (выражение) { /* делать этот код, если выражение "истина" - т.е. результат
его вычисления не ноль. Пока выполняется этот код, выражение не проверяется на
истинность! После выполнения кода происходит переход к строке while снова проверять истинность выражения. }; Цикл while
имеет вариант do – while, при котором код в { } выполняется по меньшей мере
один раз, независимо от истинности условия в скобках: do {/* сделать этот код один
раз затем, если выражение есть "истина" - т.е. результат его
вычисления не ноль - опять делать код с начала, и так до тех пор пока выражение является «истина» */ } while (выражение); for(;;){}; - этот цикл позволяет
выполнить часть программы нужное число раз: char i; /* объявление переменной для for - это обычная переменная и значит
может иметь любое допустимое имя по вашему желанию */ for
(i=5;i<20;i+=4) { /* код цикла for i=5 - это начальное выражение. Число 5 просто
для примера, может быть таким, как позволяет объявление переменной i, в нашем случае от 0 до 255, i<20 -
контрольное выражение. Может быть с разными операторами отношения, важно лишь, чтобы по ходу цикла оно
становилось когда-то "ложью" - иначе цикл "зациклится" т.е.
никогда не кончится. i+=4 –
счетчик. Обычно это i++, т.е. к переменной добавляется 1 каждый
"прогон" цикла.. Но опять же, может быть таким, какое вам требуется,
важно лишь достижение когда-либо условия абзацем выше! Иначе цикл станет бесконечным.
Код цикла for будет первый раз выполнен для i=5,
затем по выражению i+=4, i станет 9 теперь будет проверено контрольное
выражение i<20 и так как 9<20 код цикла for будет выполнен еще раз. Так будет
происходить до тех пор, пока контрольное выражение "истино". Когда
оно станет "ложно" цикл for
закончится и программа пойдет дальше. }; Начальным условием - может быть любое
допустимое в Си выражение, результатом которого является целое число. Контрольное выражение - определяет до
каких пор будет выполнятся цикл. Счетчик – показывает, как изменяется
начальное выражение, перед каждым новым выполнением цикла. Циклы for (;;) и while() часто используют вот так: while(1); for (;;); /* Так
написанные эти циклы означают: МК будет
выполнять эту строчку пока есть питание, нет сброса и нет прерывания. Когда
возникает прерывание, программа переходит на обработчик прерывания и (если в
обработчике нет перехода в другое место программы) по завершении кода
обработчика опять возвращается в такой цикл. */ switch(){}; - оператор множественного
выбора, позволяет вам сделать выбор из нескольких вариантов. switch (выражение) { case 5: /* этот код
будет выполняться, если результат вычисления выражения равен числу 5, на этом
работа оператора switch
закончится */ break; case -32: /* этот код
будет выполняться, если результат вычисления выражения равен отрицательному
числу -32, на этом работа оператора switch закончится */ break; case 'G': /* этот код
будет выполняться если результат вычисления выражения равен числу, соответствующему
символу G в таблице ASCII, на этом работа оператора switch закончится */ break; default: /* этот код
будет выполняться, если результат вычисления выражения не равен ни 5, ни - 32,
ни 'G', на этом работа оператора switch
закончится */ }; /* switch закончен - выполняется
дальнейший код программы */ case - может быть столько, сколько вам
нужно, чтобы программа работала, быстрее старайтесь наиболее вероятные варианты
располагать выше! default - не обязателен. break; - лучше писать, иначе, найдя
нужный вариант, программа будет проверять и следующие условия case - напрасно тратя время. goto - оператор безусловного
(немедленного) перехода. mesto_5: /* сюда мы попадем после
выполнения строки программы goto
mesto_5 */ goto mesto_1; /* перейти в то место
программы, где в начале строки написано mesto_1: */ goto mesto_5; /* перейти в то место
программы, где в начале строки написано mesto_5: */ mesto_1: /* сюда мы попадем после
выполнения строки программы goto
mesto_1 */ goto - существует наверно во всех
языках и в ассемблере в том числе. Используйте
его с осторожностью! Думайте, к чему может привести выполнение функций
или конструкций вашей программы не до конца. Например: Если
вы покинете функцию - обработчик прерывания по goto не завершив ее, то не произойдет
автоматического включения прерываний глобально - т.е. не установится бит I в
регистре SREG. Этот бит устанавливается
автоматически после полного выполнения функции обработки прерывания и
"естественного" выхода из неё. 5. Структура программы на языке СИ Программа на языке Си это текстовый файл
с расширением. «c». Текст
программы имеет определенную структуру: 1. заголовок 2. включение
необходимых внешних файлов 3. ваши
определения для удобства работы 4. объявление
глобальных переменных Перед использованием переменной в Си её необходимо объявить! Т.е. указать компилятору какой тип данных
она может хранить и как она называется. Глобальные переменные объявляются, вне какой либо функции. Т.е. не после
фигурной скобки {. Они доступны в любом месте программы, значит
можно читать их значения и присваивать им значения там, где требуется. 5. описание
функций - обработчиков прерываний 6. описание
других функций используемых в программе 7. функция main - это единственный обязательный пункт ! Это не жесткий порядок, а ориентировочный! Иногда п. 6 - это прототипы функций, а сами
функции описываются полностью после п. 7. Прототип функции - показывает образец
того, как применять функцию в программе, какие значения в нее передаются и,
если она возвращает какое-то значение, то прототип указывает тип возвращаемых
данных. Прототип не имеет скобок { }, а после скобок ( ) ставится знак ;. Функция - имеет { "тело" } в
фигурных скобках. Тело - это код на Си определяющий то, что делает функция.
Знак «;» после функции не
ставится. Программа на
Си начинает работу с функции main(), по необходимости из main() вызываются
другие функции программы, по завершении работы функции программа возвращается в
main(), в то место, откуда функция была вызвана. main(){ ... какой то
код программы ... вызов
функции_1; /* программа перейдет в функцию_1 строка программы */ // будет
выполнятся после // возврата из
функции_1 ... какой то
код программы ... } Функции могут
вызываться не только из main(), но и из других функций. 6. Типы данных и
их объявление Формат объявления переменной таков: [<storage modifier>] <type
definition> <identifier>; [<storage modifier>]
- необязательный элемент, он нужен только в некоторых случаях и может
быть: extern - если переменная объявляется
во внешнем файле – например, в хидере delay.h. volatile - если нужно предотвратить
повреждение содержимого переменной в прерывании, компилятор просто не будет
размещать эту переменную ни в одном из 32-х регистров общего назначения и не
будет пытаться выкинуть её при оптимизации кода. static - если переменная локальная, т.е. объявлена в какой либо функции и должна
сохранять свое значение до следующего вызова этой функции. flash и eeprom - используются с указателями. Подробней см. в Help компилятора
с языка СИ. Локальные переменные объявляются в самом
начале функции! Т.е. сразу после скобки { Локальные переменные доступны только в
той функции, где они объявлены! <type
definition> - тип данных, которые может хранить переменная. Наиболе часто используемые типы данных: unsigned char - хранит числа от 0 до
255 (байт) unsigned int - хранит числа от 0 до
65535 (слово == 2 байта) unsigned long int - хранит от 0 до
4294967295 (двойное слово == 4 байта) Подробнее все типы данных посмотрите в Help Вместо unsigned char - можно писать просто char, так как компилятор по умолчанию
считает char без знаковым
байтом. А если вам нужен знаковый байт, то объявляйте его так: signed char imya_peremennoi; <identifier>
- имя переменной - некоторый набор символов по вашему желанию, но не образующий
зарезервированные слова языка Си. Желательно давать осмысленное имя переменным
и функциям, напоминающие вам об их назначении. Принято использовать
маленькие буквы, а для отличия имен переменных от названия функций - имена
переменных можно, например, начинать
с буквы, а названия функций (кроме main
конечно) с двух символов подчеркивания. Например так: moya_peremennaya__vasha_funkziya Внимание! Глобальные переменные, а также
локальные с модификатором static
- при старте и рестарте программы равны 0, если вы не присвоили им (например,
оператором =) иное значение при их объявлении или по ходу программы. Подробные
примеры объявления переменных посмотрите, пожалуйста, в разделе Variables в
"Хелп"компилятора. Вот несколько
примеров объявления переменных: unsigned char
my_peremen = 34; unsigned int
big_peremen = 34034; Выше объявлены
две переменные с присвоением значений. Пример массива
из 3-х переменных mas[3]={11,22,33}; Три элемента:
mas[0] mas[1] mas[2] Нумерация элементов массива начинается с
нуля! Пример:
строковая переменная – массив char
stroka[7]="Hello"; /* на 2 элемента больше чем символов между
кавычками! Строковый
массив может быть распечатан одной строкой: printf ("%s\n",
stroka); Так делаются вставки ассемблерных инструкций: #asm
("инструкция на ассемблере") Обратите
внимание - точки с запятой НЕТ! Часто
используются такие строки: #asm("sei")
// Разрешить ГЛОБАЛЬНО все прерывания #asm("cli")
// Запретить ГЛОБАЛЬНО все прерывания #asm("nop")
// Пауза в 1 такт процессора #asm("wdr")
// Сбросить сторожевой таймер 7. Разделители В разделители входят следующие
символы: [], (), {}, , , ; , : , ... , * ,
= , #. [] - для записи
идентифицированных переменных. Пример №1: Int A [5] , e[3][2] ( ) применяются для: 1. выделения условия в операторе if; 2. входит как обязательный элемент
в определении любой функции; 3. группирует выражения в арифметических
операциях; 4. входит как обязательный
элемент в операторы цикла: for,
white, do. { }
используется для обозначения начала и конца составного оператора или блока
операторов. Пример №2: If (d>x) {d--; x++} Float absx (float x) { Return x>0 ? x:-x } { } также
используется для выделения списка компонентов в определениях структурных и
объединяющих типов, используются для инициализации массивов. Int month [] = {1, 2, 3, 4, 5, 6,
7,…,12}; , используется
либо в качестве операций либо в качестве разделителя. В последнем случае она
разделяет элементы из списка. ; каждый
оператор, определение и описаний в программе на языке СИ завершается знаком -
;. Любое допустимое выражение, за которым следует ; воспринимается как оперативный
отдельный символ, ; считается пустым оператором. : используется для отделения
метки от помечаемого ею оператора. ... используется для обозначения
переменного числа параметров. * используется в качестве знака
операции умножения и знака операции разыменования. = используется для присваивания
значений и инициализаций объекта. # признак препроцессорных средств
используется для обозначения директив препроцессора. 8. Пример программы на языке СИ
|
|||||||||||||||||||||||||||||||||