Основы C
for (n=1;n <=10000;n++)
; /* пустой оператор */
- использование различного шага:
for (n=1;n <=230;n=n+10)
- изменение переменных:
for (x=2;n*n <=476;n=5*x++)
Рассмотрим пример, в котором инициализируются две переменные и каждая из которых, изменяется после итерации цикла:
#include <stdio.h>
#define f 30
#define n 19
main()
{
int y,t;
for (y = 1,t=f; y<=16; y++,t+=n) /*t+=n означает t=t+n*/ printf(" %3d %7dn",y,t);
}
Далее рассмотрим, операторы ветвления (операторы перехода из одной части программы в другую).
Оператор goto позволяет передавать управление на любую строку программы. Для этой цели используется метка. Пример.
#include <iostream.h>
#include <stdio.h>
main()
{
char A;
label_1:/* метка */ printf("? n");
cin>>A;
if (A != 'y') goto label_1; }
Для прерывания цикла по некоторому условию можно использовать оператор break. Пример.
#include <stdio.h>
#include <iostream.h>
char A;
int I;
main()
{
for (I = 1; I <= 10; I++)
{
printf("? n");
cin >>A;
i (A == 'y') break;
}
}
Для прерывания итерации цикла и перехода к следующей итерации используется оператор Continue. Пример.
#include <stdio.h>
#include <iostream.h>
char A;
int I;
main()
{
for (I = 1; I <= 10; I++)
{
printf("? n");
cin >>A;
if (A == 'y') continue;
printf("Работает %cn",A);
}
}
Для прерывания программы также используются операторы return() и exit().
1.6. Препроцессор
Препроцессор языка Си позволяет перед началом трансляции включать в программу фрагменты программ, написанных отдельно от основной.
Директива #define.
Директива #define может появляться в любом месте программы, а даваемое ею определение имеет силу от места до конца программы.
#include <iostream.h>
#include <stdio.h>
#define TRI 3
#define OTWET TRI*TRI
#define OT printf("ОТВЕТ равен %d.n",OTWET)
#define jd cin >>C;
main( )
{
int C;
OT;
jd;
}
После выполнения программы получится:
ОТВЕТ равен 9
В первой строке программы TRI - это макроопределение и оно равно 3, где 3 - строка замещения.
Во второй строке макроопределение OTWET имеет строку замещения TRI*TRI и т.д. Каждая строка состоит из трех частей. Первой стоит директива #define, далее идет макроопределение. Макроопределение не должно содержать внутри себя пробелы. И, наконец, идет строка (называемая "строкой замещения"), которую представляет макроопределение. Когда препроцессор находит в программе одно из макроопределений, он заменяет его строкой замещения. Этот процесс прохождения от макроопределения до заключительной строки замещения называется "макрорасширением".
Директива #include.
Когда препроцессор "распознает" директиву #include, он ищет следующее за ней имя файла и включает его в текущую программу. Директива бывает в двух видах:
#include<stdio.h> имя файла в угловых скобках
#include "my.h" имя файла в двойных кавычках
Угловые скобки сообщают препроцессору, что файл следует искать в одном или нескольких стандартных системных каталогов. Кавычки говорят ему, что сначала нужно смотреть в рабочем каталоге, а затем искать в "стандартных" местах.
Директивы: #undef, #ifdef, #else, #endif
Эти директивы позволяют приостановить действие более ранних определений.
Директива #undef отменяет самое последнее определение поименованного макроопределения.
#define TRI 3
#define F 5
#undef TRI /* TRI теперь не определен */
#define F 10 /* F переопределен как 10 */
#undef F /* F снова равен 5 */
#undef F /* F теперь не определен */
Рассмотрим еще пример.
#ifdef OTW
#include "otw.h" /* выполнится, если OTW определен */
#define ST 10
#else
#include "w.h" /* выполнится, если OTW не определен */
#define ST 20
#endif
Директива ifdef сообщает, что если последующий идентификатор OTW определяется препроцессором, то выполняются все последующие директивы вплоть до первого появления #else или #endif. Когда в программе есть #else, то программа от #else до #endif будет выполняться, если идентификатор не определен.
1.7 Программы. Функции
Как мы рассматривали раньше, программа на Си имеет корневой сегмент, начинающийся с директив препроцессора и ключевого слова main.
Далее идет собственно программа, начинающаяся с открывающейся фигурной скобки { и заканчивающаяся закрывающейся фигурной скобкой }.
Часто используемые участки программы выделяются в функции. Каждая функция также начинается с директив препроцессора и имени и скобок { }.
Рассмотрим пример программы рисования лестницы.
#include <stdio.h>
main()
{
printf("|----|n");
printf("|----|n");
printf("|----|n");
}
А теперь напишем эту программу с использованием функции Lestniza.
#include <stdio.h>
Lestniza(void)
{
printf("|----|n");
}
main()
{
Lestniza();
Lestniza();
Lestniza();
}
Как видно из программы, обращение к функции осуществляется три раза. Для преодоления этого недостатка переработаем программу и введем формальные и фактические аргументы:
#include <stdio.h>
int C;
Lestniza(int B)/* B - формальный аргумент */
{
int A;
for (A = 1; A <= B; A++)
printf("|----|n");
}
main()
{
Lestniza(3); /* 3 -фактический аргумент */
}
В данной функции B является формальным аргументом (конечная величина оператора for to). Для присвоение ей конкретного значения используется фактический аргумент, который передается функции при ее вызове в основной программе.
Если в функцию передается несколько параметров, то они должны передаваться в том порядке, в каком записаны в функции.
Рассмотрим функции, возвращающее свое значение на примере возведения числа в квадрат.
#include <stdio.h>
float Kwadrat(float A)
{
return A * A;
}
float B;
main()
{
printf("? n");
scanf("%f",&B);
printf("Kwadrat = %8.2fn",Kwadrat(B));
}
Как видно из примера - имя функции Kwadrat - она вычисляет квадрат числа. В строке printf("Kwadrat = %8.2fn",Kwadrat(B)); эта функция вызывается - на вход подается значение (введенное число), а в результате получаем результат - квадрат числа, который возвращается в программу по команде return.
Рассмотрим еще один вариант работы с функцией, возвращающей значение без команды return.
#include <stdio.h>
Kwadrat(float A, float *B)
{
*B = A * A;
}
float C, D;
main()
{
printf("? n");
scanf("%f",&C);
Kwadrat(C,&D);
printf("Kwadrat = %8.2fn",D);
}
1.8. Указатели
Указатель - это переменная, содержащая адрес данных, а не их значение. Указатель используется:
1.Для связи независимых структур друг с другом.
2.Для динамического распределения памяти.
3.Для доступа к различным элементам структуры.
Рассмотрим следующую программу:
#include <stdio.h>
main()
{
int Z,*Y;
Y =&Z;
Z = 100;
printf("Прямое значение Z: %dn", Z);
printf("Значение Z, полученное через указатель: %dn",*Y);
printf(" Адрес Z через получение адреса: %pn",&Z);
printf("Адрес Z через указатель: %pn", Y);
}
В данном примере Y указатель на целую переменную и содержит ее адрес. В свою очередь & позволяет получить адрес по которому размещено значение переменной Z. В этой программе:
- адрес переменной Z присваивается Y;
- целое значение 100 присваивается Z;
- оператор &, позволяет получить адрес,
по которому размещено значение Z.
Результат работы программы:
Прямое значение Z: 100
Значение Z, полученное через указатель: 100
Адрес Z через получение адреса: 85B3:0FDC
Адрес Z через указатель: 85B3:0FDC
Указатели также используются для оптимального распределения памяти.
Рассмотрим пример указателя на число типа char.
#include <stdio.h>
#include <alloc.h>
#include <string.h>
#include <stdlib.h>
#include <process.h>
int main(void)
{
char *str; /* указатель на символьную переменную */
str = (char *)malloc(10);
strcpy(str, "Hello");
printf("String is %sn", str);
free(str);
return(0);
}
Вначале по команде char *str; создан тип str, который является указателем на переменную типа char(* обозначает "указатель"). По команде str = (char *)malloc(10); выделяем 10 байт памяти под переменную str(типа строка). По команде strcpy(str, "Hello"); осуществляется - "записать в область памяти, на которую указывает str, строку символов "Hello". По команде printf("String is %sn", str); осуществляется "напечатать на экране то, на что указывает str. Команда free(str); освобождает память, на которую указывает str.
Рассмотрим более сложный пример получения доступа к записи, используя указатель.
#include <stdio.h>
#include <string.h>
#include <alloc.h>
#include <process.h>
struct Student { /* запись Student */
char Fio[30]; /* поле записи Fio */
int Gruppa; /* поле записи Gruppa */
}; /* конец записи */
struct Student *A;
main()
{
if ((A =(Student *) malloc(sizeof(Student))) == NULL)
{
printf("Нет памятиn");
exit(1);
}
strcpy(A[1].Fio, "Ivanov");
A[1].Gruppa=385;
printf("Fio1 %sn Gruppa %dn", A[1].Fio, A[1].Gruppa);
strcpy(A[2].Fio, "Petrow");
A[2].Gruppa=386;
printf("Fio2 %sn Gruppa %dn", A[2].Fio, A[2].Gruppa);
free(A);
}
Указатель также может использоваться для получения косвенного указателя на структуру.
Пусть poit является указателем на структуру и что elem элемент, определенный структурным шаблоном. Тогда point->elem определяет элемент, на который выполняется ссылка. Рассмотрим предыдущий пример.
struct Student { /* запись Student */
char Fio[30]; /* поле записи Fio */
int Gruppa; /* поле записи Gruppa */
}; /* конец записи */
Student *poin;
Сейчас к полям структуры мы можем обращаться несколькими способами. Эквивалентные обращения:
Student.Gruppa=236;
poin->Gruppa=236;
Отметим одну важную особенность указателей в Си. Транслятор автоматически учитывает тип указателя в арифметических действиях над ним. Например если i есть указатель на целую (т.е. двухбайтную) переменную, то действие типа i++ означает, что указатель получает приращение не один, а два байта, т.е. будет указывать на следующую переменную или элемент массива. По этой причине указатель можно использовать вместо индексов массива. Например если A - указатель на массив целого типа, то вместо A[i] можно писать *(A+i). Более того, использование указателей вместо индексов позволяет компилятору создавать более компактный и быстрый код.
1.9 Указатели и функции
Указатели также можно использовать в качестве формальных параметров функции. Рассмотрим пример.
Функция swap (обмен) объявляет два формальных параметра x и y, как указатели на данные типа int. Это означает, что функция swap работает с адресами целых переменных (а не с их значениями). Поэтому будут обработаны данные, адреса которых переданы функции во время обращения к ней. Функция main(), вызывает swap.
#include <stdio.h>
swap(int *x, int *y)
{
int wr;
wr = *x; *x = *y; *y =wr;
}
main()
{
int i,j;
i = 100;
j = 200;
printf("Было: i=%d, j=%dn",i,j);
swap(&i,&j);
printf("Стало: i =%d, j=%dn",i,j);
}
После выполнения программы значения i и j поменяются местами. Необходимо отметить, что хотя указатели и экономят память, но они используют время процессора горазда больше.
Таким образом, рассмотрены основные элементы языка Си.
1.10 Файлы
Файл - это совокупность данных, записанных на каком-либо носителе. Файл можно создать, записать в него данные, стереть данный, обновить данные, дополнить данными. Ввод-вывод в файл осуществляется с помощью методов прямого или последовательного доступа.
Расмотрим сперва режим последовательного доступа.
Ввод-вывода буферизован. Это означает, что программа пишет и читает в буфер; обмен данными между буфером и файлом происходит в случае, если буфер полон, или произошло закрытие файла, или перед выходом из программы.
Рассмотрим пример: считать данные из одного файла и переписать в другой.
#include <stdio.h>
main()
{
FILE *in, *out;
char n1[8], n2[8];
printf("Исходный файлn");
gets(n1);
printf("Выходной файлn");
gets(n2);
if ((in = fopen(n1, "rt"))== NULL)
{
printf("Не могу открыть исходный файлn"); return 1;
}
if ((out = fopen(n2, "wt"))== NULL)
{
printf("Не могу открыть выходной файлn"); return 1;
}
while (!feof(in))
fputc(fgetc(in), out);
fclose(in);
fclose(out);
}
Строка FILE *in, *out; определяет указатель на два файла. Имя файла м.б. любым- в нашем случае in - исходный файл, out - выходной.
В следующей строке char n1[8], n2[8]; определяем две переменные n1 и n2 для хранения имен файлов. Следующие четыре строки позволяют ввести имена входного и выходного файла и присвоить эти имена переменным n1 и n2. Прежде чем начать работать с файлом он должен быть открыт. Для этого существует функция fopen() в которой первый параметр содержит имя файла, а второй - вид работы, например "rt"– читать файл.
Команда in = fopen(n1, "rt" вызовет открытие файла, запомненного в переменной n1 на чтение, и в программе будет возвращен указатель in на этот файл, которым (указателем) мы и будем пользоваться при чтении символов из файла. Если файл не существует, то значение fp будет NULL, произойдет выполнение fprintf(stderr, "Не могу открыть выходной файлn"); return 1; и программа завершит работу.
Аналогично работает функция out = fopen(n2, "wt", только теперь out - выходной файл, а вид работы "wt" -запись в файл).
По этой команде создается файл под именем, записанным в переменной n2.
Чтение из файла осуществляется вызовом fgetc(in). Читается один символ из файла, связанного с указателем in.
По команде fputc(fgetc(in), out); считанный символ записывается в файл out. Для чтения информации из всего файла используется конструкция while (!feof(in))
fputc(fgetc(in), out);.
Функция feof(in) возвращает величину, отличную от нуля, если находится в конечной позиции, и ноль - в противном случае. Пока не встретится ноль, данные из исходного файла читаются и записываются в выходной.
Закрытие файла происходит при вызове функции fclose(). Если при этом файл был открыт на запись, происходит вывод содержимого буфера, связанного с этим файлом. Связь между указателем и файлом разрывается.
Аналогично функция fgetc(string,n,fp) читает из файла, связанного с fp, строку и помещает ее в string. Символы читаются, пока не будет получен символ 'n', или пока не исчерпается файл, или пока не будет прочитано (n-1) символов.
Режим прямого доступа более гибок, т.к. позволяет обращаться напрямую к любой записи файла. Минимальной записью для файла прямого доступа является байт. Ниже будет рассмотрен случай файла прямого доступа с записью равной байту. Такие файлы называются двоичными. Файлы прямого доступа незаменимы при написании программ, которые должны работать с большими объемами информации, хранящимися на внешних устройствах. В основе обработке СУБД лежат файлы прямого доступа.
Кратко изложим основные положения работы с файлами прямого доступа.
1). Каждая запись в файле прямого доступа имеет свой номер. Записи нумерются от 0 до N-1, где N - количество записей в файле. Для двоичного файла N совпадает с длиной файла в байтах. Для открытого файла одна из записей является текущей - говорят, что указатель установлен на данную запись. Перемещать указатель можно при помощи функции lseek.
2). При открытии (или создания файла) указатель автоматически помещается на начало (запись 0). При выполнении операций чтения или записи указатель автоматически перемещается за последнюю считанную (записанную запись) запись.
3). Изменить размер файла (увеличить или урезать) можно при помощи функции chsize. При увеличении размера файла к нему добавляются записи, заполненные кодами 0.
Ниже представлена программа, демонстрирующая работу с файлами.
#include <stdio.h>
#include <io.h>
#include <string.h>
#include <fcntl.h>
#include <SYSSTAT.H>
void main()
{
int h; /*дескриптор создаваемого файла*/
char * s="Эта строка будет помещена в файл";
char buf[7]; /*буфер для чтения из файла*/
_fmode=O_BINARY; /*работаем с двоичными файлами*/
if((h=creat("proba.txt",S_IREAD |S_IWRITE))==-1) /*создать файл*/
{
printf("Не удалось открыть файл!n");
exit(1);
}
write(h,s,strlen(s)); /*записать в файл строку s*/
lseek(h,4,SEEK_SET); /*четвертый байт от начала файла*/
read(h,buf,6); /*читать слово 'строка' (6 байт) из файла*/
buf[6]=0; /*отмечаем конец строки*/
close(h); /*закрыть файл*/
printf("%sn",buf); /*печать считанной строки*/
}
Наша программа достаточно полно прокоментирована, поэтому мы приводим достаточно краткие пояснения. Программа создает файл прямого доступа и записывает туда последовательность байт (строку). Далее происходит прямое обращение к подстроке этой строки непосредственно в файле. При разборе текста программы обратим читателей на некоторые моменты:
Обработка ошибки создания файла. Действительно, открытие файла может быть не удачным и в хорошая программа должна обрабатывать такие ситуации.
При удачном открытии файла ему отводится дескриптор (уникальное число), по которому затем можно к файлу обращаться.
Наконец не забывайте, что строка только тогда станет строкой, когда в конце стоит код .
В заключении нашего рассмотрения файлов отметим, что наше изложение касалось работы с файлами в среде MS DOS. Работа с файлами в ОС Windows несколько отличается от рассмотренного и основывается на использовании специальных функций API (о программировании в Windows см. ниже).
1.11 Дополнительные функции Си
1.11.1 Функции преобразования
Имеется переменная С:
ФУНКЦИЯ ПРОВЕРЯЕТ, ЯВЛЯЕТСЯ ЛИ C
isalpha(c) буквой
isdigit(c) цифрой
islower(c) строчной буквой
isspace(c) пустым символом (пробел, табуляция или новая строка)
isupper(c) прописной буквой
isalnum(c) алфавитноцифровым (буква или цифра)
isascii(c) кодом ASCII (0-127)
iscntrl(c) управляющим символом
ispunct(c) знаком пунктуации
toupper(c) преобразует c в прописную букву
tolower(c) преобразует c в строчную букву
Пример: преобразует букву A из прописной в строчную a.
#include <stdio.h>
#include <ctype.h>
main()
{
char Z,Y='A';
printf("Было %cn ",Y);
Z=tolower(Y);
printf("Стало %cn ",Z);
}
1.11.2 Преобразования символьных строк: atoi(), atof()
При вводе информации иногда целесообразнее ввести строку символов, а затем преобразовать в соответствующее число.
Для этого используются функции atoi() и atof(). Первая преобразует строку в целое, вторая - в число с плавающей точкой. Пример:
#include <stdlib.h>
#include <stdio.h>
main()
{
char ch[10];
int integ;
puts("Введите, пожалуйста, целое");
gets(ch);
integ=atoi(ch);
printf("Число было %d.n", integ);
}
1.11.3 Функции, работающие со строками
strlen()- находит длину строки;
strcat()- объединяет две строки;
strcmp()- сравнивает содержимое строк;
strcpy()- копирует строки.
Рассмотрим пример.
#include <string.h>
#include <stdio.h>
main()
{
char k[60]="Есть в дожде откровенье";
char l[20]="Потаенная нежность";
printf("Длина 1 строки= %dn ",strlen(k));
strcat(k,l);
puts(k);
}
В результате выполнения программы получится: Длина 1 строки= 24. Есть в дожде откровенье, Потаенная нежность.
В данном примере функция strlen(k) определяет длину строки k.
Функция strcat(k,l) присоединяет к концу строки k строку l.
1.12 Особенности программирования на языке Си
1.12.1 Модули. Многомодульное программирование
Можулем будем называть часть программы помещенная в отдельный файл и транслируемая независимо от других частей программы. Т.о. часть программы подключаемая при помощи препроцессорной команды include, согласно нашему определению, модулем являтся не будет. Напомним читателю некоторые стандартные положения трансляции программ:
Стандартный процесс трансляции состоит из двух этапов: собственно трансляции и редактирования связей.
На первой стадии трансляции текстовый файл, содержащий фрагмент программы преобразуется к объектному виду.
На второй стадии трансляции все объектные модули (в том числе модули, содержащиеся в стандартных и других библиотеках) объединяются в один исполняемый модуль. На этой стадии происходит согласование используемых внешних переменных и внешних функций.
На первый взгляд кажется, что двухэтапный процесс трансляции усложняет и замедляет разработку программного обеспечения. Однако, разбивая программу на модули мы можем перевести их в объектный формат и далее подсоединять их только на втором этапе трансляции, что, в конечном итоге, ускоряет процесс трансляции. Кстати, все стандартные функции, которыми Вы пользуетесь в своих программах содержаться, в стандартных библиотеках объектных модулей. Описание же библиотечных функций содержится в H-файлах. Заметим, что при любом количестве модулей один и только один будет содержать функцию main. Этот модуль мы будем называть главным.
Современные средства трансляции позволяют легко разрабатывать многомодульные программы. Работая с Borland С вы можете либо включить все модули в проект (если Вы работаете с интегрированной средой) либо указать их в командном файле (если Вы работаете ) со строковым компилятором. При этом на первом месте должен стоять главный модуль. При этом, если Вы указали модуль с расширением .obj, то он будет учавствовать только во второй стадии трансляции, в противном случае он каждый раз будет перекомпилироваться. Стандартные библиотеки в проекте указывать не надо - система автоматически подключает их на втором этапе трансляции.
При разработке программного обеспечения разбиение на модули осуществляется тематически. Например, в один модуль помещаются все функции работающие с файлами, во второй - функции, осуществляющие математические расчеты и т.д.
Заканчивая общетеоретическое рассмотрение модульного программирования заметим, что в нем имеется еще один положительный момент. Дело в том, что двух-этапный процесс трансляции и структура объектных файлов являются стандартом для многих трансляторов с языков высокого уровня, а также ассемблеров. Т.о. появляется возможность собирать программы, модули которых были написаны на разных языках. Ниже нами будет приведен пример использования модулей, написанных на языке ассемблера.
Приведем пример двухмодульной программы.
/*Модуль 1, главный*/
#include <stdio.h>
extern int min(int, int, int); /*находит минимальное значение из 3*/
extern int max(int, int, int); /*находит максималное значение из 3*/
void main ()
{
int a,b,c;
a=2; b=10; c=14;
/*напечатать произведение минимального и максимального числа*/
printf("%dn", max(a,b,c)*min(a,b,c)); /*ответ 28*/
}
/*Модуль 2*/
#include <stdio.h>
extern int min(int, int, int); //находит минимальное значение из 3
extern int max(int, int, int); //находит максималное значение из 3
int max(int a1, int b1, int c1)
{
if(a1>b1)
{
if(c1>a1)return c1; else return a1;
}
else
{
if(b1>c1)return b1; else return c1;
}
}
int min(int a1, int b1, int c1)
{
if(a1<b1)
{
if(c1<a1)return c1; else return a1;
}
else
{
if(b1<c1)return b1;
else return c1;
}
}
Кратко прокоментируем приведенную выше программу.
Программа состоит из двух модулей. В главном модуле содержаться вызовы функций, которые содержаться во втором модуле. Как видно из текста программы при описании функций мы используем ключевое слово extern. Пусть первая программа называется modul1, а вторая modul1. Тогда после первого этапа трансляции на диске появятся объектные модули modul1.obj и modul2.obj. На втором этапе трансляции происходит объединение этих модулей и на диске появляется исполняемый модуль modul1.exe.
1.12.2 Модели памяти
Обратимся теперь к одной весьма важной проблеме, с которой рано или поздно сталкивается любой программист программирующий на Си в операционной системе MS DOS. Эта проблема называется - выбор модели памяти. Выбор модели памяти можно осуществить отметив соответствующие опции в интегрированной среде обработки или или указав соответствующие параметры для строкового компилятора. Вопрос заключается в том: что означает выбранная модель памяти.
Чтобы разобраться в указанной проблеме прежде всего следует обратиться к тому как осуществляется адресация памяти на компьютерах IBM. Прежде всего заметим, что микропроцессор Intel может работать в двух режимах реальном и защищенном, отличающихся в том числе и системой адресации. Операционная система MS DOS работает в реальном режиме (или в имитированном реальном режиме). Начнем, поэтому, с адресации в реальном режиме.
Поскольку первые микропроцессоры Intel были 16-битные то для того, чтобы расширить объем адресуемой памяти, адрес ячейки памяти формируется из двух компонент. Обозначим первую компоненту как seg и назовем ее сегментным адресом. Вторую компоненту обозначим ofs и назовем ее смещением. Тогда физический адрес ячейки может быть найден по формуле: seg*16+ofs. Поскольку размер регистров составляет 16 бит, то имеем, что максимальный возможный адрес составляет (2^16-1)*16+(2^16-1). Т.е. объем охватываемой памяти оказывается равным приблизительно 1 Мб.
Заметим, что при фиксированном seg смещение позволяет адресовать 64 Кб памяти. В результате вся память разбивается на сегменты. Максимальный размер сегмента составляет 64 Кб. Адрес начала сегмента всегда кратен 16. Такую сегментную структуру приходится учитывать и при написании программы. Традиционно в программе можно выделить три компонента: код, данные, стек. Для каждой из этих компонент должно быть выделено определенное количество сегментов.
Для сегментации сегментов в микропроцессоре Intel существует 4 регистра называемых сегментными: cs - регистр сегмента кода, ds - регистр сегмента данных, ss - регистр сегмента стека, es - дополнительный сегментный регистр.
Ранее было введено понятие указателя. До сих пор мы пользовались этим понятием не задумываясь о их типе. Этот тип устанавливается по умолчанию согласно модели памяти (см. ниже). В Си существует 3 типа указателя: NEAR, FAR и HUGE.
Указатель NEAR - соответствует смещению в текущем сегменте. Длина его 16 бит.
Указатель FAR - 32-битный указатель, точнее пара SEG,OFS. Легко видеть, что один и тот же физический адрес может быть представлен несколькими парами: seg,ofs. Кроме того сравнение и действия над указателями касается только смещения. Т.о. два указателя относящиеся к одной и той же ячейки памяти оказываются не равными друг другу.
Указатель HUGE - 32-битный указатель. Отличается от FAR тем, что он нормализован - из всех пар seg,ofs выбрана пара с минимальным ofs. Такой вид указателя называется нормализованным.
Перейдем теперь непосредственно к рассмотрению моделей памяти, коих существует ровно 6.
Модель tiny (крохотная). Все сегментные регистры (cs,ds,ss,es) указывают на один адрес. Т.о. у Вас для всего (кода, данных, стека) всего 64 Кб. памяти. Используются только указатели типа near. Программы написанные в этой модели могут быть преобразованы к COM-виду.
Модель small (малая). Программный сегмент и сегмент данных начинаются с разных адресов. Т.е. для кода и для стека отводится по 64 Кб. Сегмент стека начинается с того же адреса, что сегмент данных. Используются только указатели near.
Модель medium (средняя). Может иметь несколько сегментов кода, но один сегмент данных. Другими словами указатели типа far определены только для сегментов кода. Сегмент стека начинается с адреса сегмента данных.
Модель compact (компактная). Может иметь несколько сегментов данных (один для статических данных), но один сегмент кода. Другими словами указатели типа far определены для сегментов данных (и стека). Стек имеет свой собственный сегмент.
Модель large (большая). Может иметь несколько сегментов кода и данных. Для стека, как и в предыдущем случае, имеется свой сегмент. Используется указатель типа far. Для статических данных отводится один сегмент.
Модель huge (огромная). Совпадает с предыдущей, но снимается ограничение на количество сегментов для статических данных.
Предыдущий материал показывает какие указатели используются по умолчанию в той или иной модели памяти. Однако используя модификаторы near, far и huge можно изменить тип указателя задаваемого по умолчани.
1.12.3 Программирование в DOS и Windows
До сих пор мы не акцентировали Ваше внимание на то в какой операционной системе мы работаем. Для начала программирования на Си это не имеет большого значения. Однако теперь мы можем сказать, что настоящее программирование в Windows начнется только с Главы 4. В данном параграфе мы поговорим о принципиальных особенностях программирования в среде MS DOS и Windows.
Значительная часть времени в программировании уходит на про-граммирование внешних устройств. Причем под внешними устройствами понимается и работа с памятью, файловой системой, дисплеем, клавиатурой, мышью и т.д. Основным отличием операционной системы Windows от MS DOS является то, все управление всеми внешними устройствами Windows берет на себе. Ниже на рисунке представлена схема взаимодействия приложения с внешними устройствами в системах MS DOS и Windows
Беря на себя взаимодействие с внешними устройствами Windows позволяет создавать более надежное и совместимое программное обеспечение.
Вторым преимуществом операционной системы Windows является ее многозадачность. Все задачи, запускаемые в ОС оказываются совершенно равноправными по отношению к рессурсам микропроцессора. Замечательно и то, что многозадачность возможна и в рамках одной задачи, когда две функции могут выполняться параллельно и независимо друг от друга.
Еще одной особенностью програмирования в среде Windows является присутствие только одной модели памяти. в Windows используется так называемая линейная или плоская модели памяти. Суть этой модели заключается в том, что содержание всех сегментных регистров фиксируется, а адресация осуществляется с помощью 32-битных регистров. Такая модель основывается на так называемой страничной адресации в защищенном режиме. Для программирования это дает значительные преимущества, заключающиеся в том, что поскольку сегментом теперь является вся память, то снимаются все ограничения на размер кода, данных, стека и объема отводимого под локальные переменные.
К особенностям программирования в Windows мы еще вернемся в Главе 4, а пока познакомимся с тем, как можно непосредственно использовать системные вызовы в программах для операционной системы MS DOS.
Ниже приведена программа, которая для печати строки использует системный вызов (так называемое 21-е прерывание).
#include <stdio.h>
#include <dos.h>
void main()
{
char *s="Печать с помощью системного вызова ";
struct REGPACK r;
r.r_ax=0x0200; /*функция 2, 21-его прерывания*/
r.r_ds=FP_SEG(s);
r.r_bx=FP_OFF(s);
while (*(char *)MK_FP(r.r_ds,r.r_bx)!=0)
{
r.r_dx=*(char *)MK_FP(r.r_ds,r.r_bx);
intr(0x21,&r);
r.r_bx++;
}
}
Прокоментируем программу. В программе используется функция INTR, позволяющая осуществлять системные вызовы операционной системы MS DOS. Эти системные вызовы называются прерываниями и имеют свой номер. Наиболее часто используемое прерывание имеет номер 21 (шестнадцатиричный). В нашей программе мы используем функцию 2 этого прерывания, которая позволяет печатать один символ, код которого помещен в регистр DX. Для работы с регистрами используется предопределенная структура REGPACK. Особо обращаем внимание на функции FP_SEG, FP_OFF, MK_FP. FP_SEG и FP_OFF позволяют получать по указателю сегментный адрес и смещение. Функция MK_FP наоборот формирует указатель исходя из сегментного адреса и смещения. Напоминаем, что на конце строки стоит символ с кодом 0, на