Объявление новых типов переменных

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

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

При объявлении типа с ключевым словом typedef идентификатор, стоящий на месте описываемого объекта, является именем объявляемого типа данных, и далее этот тип может быть использован для объявления переменных.

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

Примеры объявления и использования новых типов:

 

typedef float (* MATH)(); // MATH - новое имя типа, представляющее указатель на функцию, //возвращающую значения типа floattypedef char FIO[40] // FIO - массив из сорока символов MATH cos; // cos указатель на функцию, возвращающую значения типа double // Можно провести эквивалентное объявление float (* cos)(); FIO person; //Переменная person - массив из сорока символов // Это эквивалентно объявлению char person[40];

При объявлении переменных и типов здесь были использованы имена типов MATH и FIO. Помимо объявления переменных, имена типов могут еще использоваться в трех случаях: в списке формальных параметров при объявлении функций, в операциях приведения типов и в операции sizeof.

Инициализация данных

В языке программирования C-51, как и в других версиях языка C при объявлении переменной ей можно присвоить начальное значение, присоединяя инициатор к описателю. При этом во время запуска Вашей программы в ячейки памяти, соответствующие этим переменным будут записаны начальные значения. Только после этого выполнение программы будет передано подпрограмме main();.

Инициатор переменной начинается со знака "=" и может быть записан в следующих форматах:

 

Формат 1: = инициатор;
Формат 2: = { список - инициаторов };

Формат 1 используется при инициализации переменных основных типов и указателей, а формат 2 — при инициализации составных объектов.

Примеры присваивания первоначальных значений простым переменным:

 

char tol = 'N'; //Переменная tol инициализируется символом 'N'.const long megabyte = (1024*1024);

Немодифицируемой переменной megabyte присваивается значение константного выражения, после чего эта переменная не может быть изменена. Отмечу, что для микроконтроллеров семейства MCS-51 внутренняя память является дефицитным ресурсом, поэтому использовать ее для хранения констант нерационально. Лучше объявить переменную со спецификатором типа памяти code.

static int b[2][2] = {1,2,3,4};

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

 

static int b[2][2] = { { 1,2 }, { 3,4 } };

При инициализации массива можно опустить одну или несколько размерностей:

 

static int b[3] = { { 1,2 }, { 3,4 } };

Если при инициализации указано меньше значений для строк, то оставшиеся элементы инициализируются 0, т.е. при описании:

 

static int b[2][2] = { { 1,2 }, { 3 } };

 

элементы первой строки получат значения 1 и 2, а второй 3 и 0.

При инициализации составных объектов, нужно внимательно следить за использованием скобок и списков инициализаторов.

Примеры:

 

struct complex {float real; float imag; }comp[2][3]={{{1,1},{2,3},{ 4, 5}}, {{6,7},{8,9},{10,11}} };

В данном примере инициализируется массив структур comp из двух строк и трех столбцов, где каждая структура состоит из двух элементов real и imag.

 

struct complex comp2 [2][3] = { {1,1},{2,3},{4,5},{6,7},{8,9},{10,11} };

В этом примере компилятор интерпретирует рассматриваемые фигурные скобки следующим образом:

75. первая левая фигурная скобка — начало составного инициатора для массива comp2;

76. вторая левая фигурная скобка — начало инициализации первой строки массива comp2[0]. Значения 1,1 присваиваются двум элементам первой структуры;

77. первая правая скобка (после 1) указывает компилятору, что список инициаторов для строки массива окончен, и элементы оставшихся структур в строке comp[0] автоматически инициализируются нулем;

78. аналогично список {2,3} инициализирует первую структуру в строке comp[1], а оставшиеся структуры массива обращаются в нули;

79. на следующий список инициализаторов {4,5} компилятор будет сообщать о возможной ошибке, так как строка 3 в массиве comp2 отсутствует.

При инициализации объединения задается значение первого элемента объединения в соответствии с его типом.

Пример инициализации объединения:

 

union tab {unsigned char name[10]; int tab1; }pers={'A','H','T','O','H'};

Инициализируется переменная pers.name, и так как это массив, для его инициализации требуется список значений в фигурных скобках. Первые пять элементов массива инициализируются значениями из списка, остальные нулями.

Инициализацию массива символов можно выполнить при помощи литеральной строки.

 

char stroka[ ] = "привет";

Инициализируется массив символов из 7 элементов, последним элементом (седьмым) будет символ '\0', которым завершаются все литеральные строки.

В случае если задается размер массива, а литеральная строка длиннее, чем размер массива, то лишние символы отбрасываются. Следующее объявление инициализирует переменную stroka как массив, состоящий из семи элементов.

 

char stroka[5]="привет";

В переменную stroka попадают первые пять элементов литерала, а символы 'т' и '\0' отбрасываются. Если строка короче размерности массива, то оставшиеся элементы массива заполняются нулями. Отметим, что инициализация переменной типа tab может иметь следующий вид:

 

union tab pers1="Антон";

и, таким образом, в символьный массив попадут символы:

 

'А','Н','Т','О','Н','\0',

а в остальные элементы будут записаны нули.

Использование функций в языке программирования С‑51

В отличие от других языков программирования высокого уровня в языке C нет деления на основную программу, процедуры и функции. В этом языке вся программа строится только из функций. Мощность языка C во многом определяется легкостью и гибкостью объявления и реализации функций.

Функция — это совокупность объявлений и операторов, обычно предназначенная для решения определенной задачи. Термин функция в языке программирования C эквивалентен понятию подпрограммы. Действия, выполняемые основной программой в других языках программирования, такие как очистка внутреннего ОЗУ и присваивание начального значения переменным, выполняются автоматически при включении питания. После завершения этих действий вызывается подпрограмма с именем main. Каждая функция должна иметь имя, которое используется для ее объявления, определения и вызова.

В любой программе, написанной на языке программирования С-51 должна быть функция с именем main (главная функция), именно с этой функции, в каком бы месте программы она не находилась, начинается выполнение программы. Обратите внимание, что на языке программирования С-51 пишутся программы для микроконтроллеров. Поэтому эти программы не должны завершаться до тех пор, пока включено питание микроконтроллера. Это значит, что в функции main обязательно должен быть бесконечный цикл. В противном случае при выходе из этой функции управление будет передано случайному адресу памяти программ. Это может привести к непредсказуемым результатам, вплоть до выхода микроконтроллерной системы из строя.

При вызове функции ей при помощи аргументов (формальных параметров) могут быть переданы некоторые значения (фактические параметры), используемые во время выполнения функции. Функция может возвращать некоторое, но только одно, значение. Это возвращаемое значение и есть результат выполнения функции, который при выполнении программы подставляется в выражение, из которого производился вызов функции.

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

С использованием функций в языке С‑51 связаны три понятия — определение функции (описание действий, выполняемых подпрограммой-функцией), объявление функции (задание формы обращения к функции) и вызов функции.

Определение функций

Определение функции состоит из заголовка и тела. Определение функции записывается в следующем виде:

 

[спецификатор класса памяти] [спецификатор типа] имя функции ([список формальных параметров]) //Заголовок функции{ //тело функции }

Заголовок функции задает тип возвращаемого значения, имя функции, типы и число формальных параметров.

Тело функции — это составной оператор, содержащий операторы, определяющие действие функции. Тело функции начинается с фигурной скобки '{' и состоит из объявления переменных и исполняемых операторов. Именно эти операторы, входящие в тело функции, и определяют действие функции. Завершается тело функции закрывающей фигурной скобкой '}'.

Пример определения функции:

 

bit SostKnIzm(void)//Заголовок функции{//---------------начало тела функции-------------- bit tmp=0; if(P0!=0xff)tmp=1; return tmp;}//---------------конец тела функции----------------- //================== Вызывающая подпрограмма ==========... if(SostKnIzm()) //Вызов подпрограммы SostKnIzm DecodSostKn();

В приведенном примере показано как при помощи функции, возвращающей битовую переменную можно повысить наглядность исходного текста программы. Оператор if(SostKnIzm()) DecodSostKn(); практически не требует комментариев. Имя функции SostKnIzm показывает, что контролирует эта функция.

Необязательный спецификатор класса памяти задает класс памяти функции, который может быть static или extern.

При использовании спецификатора класса памяти static функция становится невидимой из других файлов программного проекта, то есть информация об этой функции не помещается в объектный файл. Использование спецификатора класса памяти static может быть полезно для того, чтобы имя этой функции могло быть использовано в других файлах программного проекта для реализации совершенно других задач. Если функция, объявленная с спецификатором класса памяти static, ни разу не вызывалась в данном файле, то она вообще не транслируется компилятором и не занимает места в программной памяти микроконтроллера, а программа-компилятор языка программирования С-51 выдает предупреждение об этом. Это свойство может быть полезным при отладке программ и программных модулей.

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

Спецификатор типа функции задает тип возвращаемого значения и может задавать любой тип. Если спецификатор типа не задан, то по умолчанию предполагается, что функция возвращает числовое значение типа int. Функция не может возвращать массив или функцию, но это ограничение можно обойти, так как она может возвращать указатель на любой тип, в том числе и на массив и на функцию. Тип возвращаемого значения, задаваемый в определении функции, должен соответствовать типу в объявлении этой функции.

Функция возвращает значение, если ее выполнение заканчивается оператором return, содержащим некоторое выражение. Указанное выражение вычисляется, преобразуется, если необходимо, к типу возвращаемого значения и возвращается в точку вызова функции в качестве результата. Пример определения функции, возвращающей двоичный код числа, принятого по последовательному порту микроконтроллера:

 

#include <reg51.h>//Подключить описания внутренних регистров микроконтроллера char getkey () //Заголовок функции, возвращающей байт, принятый по последовательному порту{while (!RI); //Если последовательный порт принял байт, RI = 0; //то подготовиться к приёму следующего байта return (SBUF); //и передать принятый байт в вызывающую подпрограмму.}

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

Для функций, не использующих возвращаемое значение (подпрограмм-процедур), должен быть использован тип void, указывающий на отсутствие возвращаемого значения. Если оператор return не содержит выражения или выполнение функции завершается после выполнения последнего ее оператора (без выполнения оператора return), то возвращаемое значение не определено. Пример функции, не возвращающей значение:

 

void putchar (char c) //Заголовок функции, передающей один байт через последовательный порт{while (!TI); //Если передатчик последовательного порта готов к передаче байта SBUF = c; //то занести в буфер передатчика последовательного порта байт TI = 0; //и начать передачу}

Все переменные, объявленные в теле функции без указания класса памяти, имеют класс памяти auto, т.е. они являются локальными. Так как глубина стека в процессорах семейства MCS-51 ограничена 256 байтами, то при вызове функций аргументам назначаются конкретные адреса во внутренней памяти микроконтроллера и производится их инициализация. Управление передается первому оператору тела функции и начинается выполнение функции, которое продолжается до тех пор, пока не встретится оператор return или последний оператор тела функции. Управление при этом возвращается в точку, следующую за точкой вызова, а локальные переменные становятся недоступными. При выходе из функции значения этих переменных теряются, так как при вызове других функций эти же ячейки памяти распределяются для их локальных переменных.

Если необходимо, чтобы переменная, объявленная внутри подпрограммы сохраняла своё значение при следующем вызове подпрограммы, то ее необходимо объявить с классом памяти static.

Параметры функций

Список формальных параметров — это последовательность объявлений формальных параметров, разделенная запятыми. Формальные параметры — это переменные, используемые внутри тела функции и получающие значение при вызове функции путем копирования в них значений соответствующих фактических параметров.

Пример определения функции с одним параметром:

 

int rus (unsigned char r) //Заголовок функции{//---------------начало тела функции-------------- if (r>='А' && c<=' ') return 1; else return 0; }//---------------конец тела функции-----------------

В данном примере определена функция с именем rus, имеющая один параметр с именем r и типом unsigned char. Функция возвращает целое значение, равное 1, если параметр функции является буквой русского алфавита, или 0 в противном случае.

Если функция не использует параметров, то наличие круглых скобок обязательно, а вместо списка параметров рекомендуется указать слово void. Например:

 

void main(void) {P0=0; //Зажигание светодиода while(1); //Бесконечный цикл}

Порядок и типы формальных параметров должны быть одинаковыми в определении функции и во всех ее объявлениях. Поэтому желательно объявление функции поместить в отдельный файл, который затем можно включить в исходные тексты программных модулей при помощи директивы #include. Типы фактических параметров при вызове функции должны быть совместимы с типами соответствующих формальных параметров. Тип формального параметра может быть любым основным типом, структурой, объединением, перечислением, указателем или массивом. Если тип формального параметра не указан, то этому параметру присваивается тип int.

Для формального параметра можно задавать класс памяти register, при этом для величин типа int спецификатор типа можно опустить. Однако все известные мне компиляторы языка программирования С‑51 игнорируют этот спецификатор, так как расположение параметров в памяти микроконтроллера оптимизируется с точки зрения использования минимального количества необходимой внутренней памяти.

По умолчанию компиляторы стараются передавать параметры в функцию через регистры, тем самым максимально сохраняя внутреннюю память микроконтроллеров. Номера регистров, используемые для передачи параметров в функцию в зависимости от типа аргументов, приведены в табл. 22.9.

Таблица 22.9.

Номер аргумента	char, однобайтовый указатель	int, двухбайтовый указатель	long, float	Нетипизированные указатели
	R7	R6,R7	R4 - R7	R1 - R3
	R5	R4,R5	R4 - R7	R1 - R3
	R3	R2,R3		R1 - R3

 

Поскольку при вызове функции значения фактических параметров копируются в локальные переменные, в теле функции нельзя изменить значения переменных в вызывающей функции. Например, нужно поменять местами значения переменных x и y:

 

/* Неправильное использование параметров функции */void change (int x, int y){int k=x; x=y; y=k;}

В данной функции значения локальных переменных x и y, являющихся формальными параметрами, меняются местами, но поскольку эти переменные существуют только внутри функции change, значения фактических параметров, используемых при вызове функции, останутся неизменными.

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

 

/* Правильное использование параметров функции */void change (int *x, int *y){int k=*x; *x=*y; *y=k;}

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

change (&a,&b);

Предварительное объявление подпрограмм

В языке С‑51 нет требования, чтобы определение функции обязательно предшествовало ее вызову. Определения используемых функций могут следовать за определением функции main, перед ним, или находится в другом файле. Однако для того, чтобы компилятор мог осуществить проверку соответствия типов передаваемых фактических параметров типам формальных параметров и, если необходимо, выполнил соответствующие преобразования, до вызова функции нужно поместить объявление (прототип) функции.

Если объявление функции не задано, то по умолчанию строится прототип функции на основе анализа первого вызова функции. Тип возвращаемого значения создаваемого прототипа int, а список типов и числа параметров функции формируется на основании типов и числа фактических параметров, используемых при данном вызове. Однако такой прототип не всегда согласуется с последующим определением функции. При размещении функции в другом файле или после оператора ее вызова рекомендуется задавать прототип функции. Это позволит компилятору либо выдавать диагностические сообщения, при неправильном использовании функции, либо правильным образом преобразовывать типы аргументов при её вызове.

Прототип — это явное объявление функции, которое предшествует определению функции. Тип возвращаемого значения при объявлении функции должен соответствовать типу возвращаемого значения в определении функции. Если прототип задан с классом памяти static, то и определение функции должно иметь класс памяти static. Объявление (прототип) функции имеет следующий формат:

[спецификатор класса памяти] [спецификатор типа] имя функции ([список формальных параметров]);

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

Для функции, определенной в предыдущем параграфе, прототип может быть записан в следующем виде:

 

int rus (unsigned char r);

При этом в объявлении функции имена формальных параметров могут быть опущены:

 

int rus (unsigned char);

Вызов функций

Вызов функции имеет следующий формат:

 

имя функции ([список выражений]);

Список выражений представляет собой список фактических параметров, передаваемых в функцию. Этот список может быть и пустым, если в определении функции отсутствуют параметры, но наличие круглых скобок обязательно. Примеры вызова функции (подпрограммы-процедуры):

 

DecodSostKn();VypFunc();

Функция, если она возвращает какое-либо значение (подпрограмма-функция), может быть вызвана и в составе выражения, например:

 

y=sin(x); //sin - это имя подпрограммы-функцииif(rus(c))SvDiod=Gorit; //rus - это имя подпрограммы-функции

Выполнение вызова функции происходит следующим образом:

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

81. Происходит присваивание значений фактических параметров соответствующим формальным параметрам.

82. Управление передается на первый оператор функции.

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

 

int (*fun)(int x, int *y);

Здесь объявлена переменная fun как указатель на функцию с двумя параметрами: типа int и указателем на int. Сама функция должна возвращать значение типа int. Круглые скобки, содержащие имя указателя fun и признак указателя *, обязательны, иначе запись

 

int *fun (int x,int *y);

будет интерпретироваться как объявление функции fun возвращающей указатель на int.

Вызов функции возможен только после инициализации значения указателя:

 

float (*funPtr)(int x, int y);float fun2(int k, int l);... funPtr=fun2; /* инициализация указателя на функцию */ (*funPtr)(2,7); /* обращение к функции */

 

В рассмотренном примере указатель на функцию funPtr описан как указатель на функцию с двумя параметрами, возвращающую значение типа double, и также описана функция fun2. В противном случае, т.е. когда указателю на функцию присваивается функция, описанная иначе, чем указатель, произойдет ошибка.

Рассмотрим пример использования указателя на функцию в качестве параметра функции вычисляющей производную от функции cos(x).

Пример:

 

float proiz(float x,float dx,float(*f)(float x));float fun(float z); int main(){float x; /* точка вычисления производной */ float dx; /* приращение */ float z; /* значение производной */ scanf("%f,%f",&x,&dx); /* ввод значений x и dx */ z=proiz(x,dx,fun); /* вызов функции */ printf("%f",z); /* печать значения производной */} float proiz(float x,float dx,float (*f)(float z))/* функция вычисляющая производную */{float xk,xk1; xk=fun(x); xk1=fun(x+dx); return (xk1/xk-1e0)*xk/dx;} float fun(float z) /* функция от которой вычисляется производная */{return (cos(z));}

Для вычисления производной от какой-либо другой функции можно изменить тело функции fun или использовать при вызове функции proiz имя другой функции. В частности, для вычисления производной от функции cos(x) можно вызвать функцию proiz в форме:

 

z=proiz(x,dx,cos);

а для вычисления производной от функции sin(x) в форме

 

z=proiz(x,dx,sin);