Понедельник , 30 марта 2020
Новости
Главная / Студентам / ОСиС / Лекция № 12. ВВЕДЕНИЕ В СИСТЕМНОЕ ПРОГРАММИРОВАНИЕ

Лекция № 12. ВВЕДЕНИЕ В СИСТЕМНОЕ ПРОГРАММИРОВАНИЕ

Fortunato 25.11.2019 ОСиС, Студентам 107 Просмотры

12.1. Основные понятия 

Системная программа – программа, предназначенная для поддержания работоспособности прикладных программ пользователя или для повышения эффективности их использования. 

Прикладная программа – программа, предназначенная для решения задач в определенной области науки, техники, культуры, или для личных нужд пользователя. 

Системное программирование – это процесс разработки системных программ. 

В последнее время появилось понятие промежуточного программного обеспечения (ПО), включающего в себя элементы как системного, так и прикладного программирования. 

Промежуточное ПО (middleware) – это совокупность программ, осуществляющих управление вторичными (конструируемыми самим ПО) ресурсами, ориентированными на решение широкого класса задач универсального значения. К такому ПО относятся менеджеры транзакций, серверы БД, серверы коммуникаций и другие программные серверы.  

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

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

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

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

Системное ПО подразделяется на системные управляющие программы и системные обслуживающие программы.  

Управляющая программа – системная программа, реализующая набор функций управления, который включает в себя управление ресурсами и взаимодействие с внешней средой, восстановление работы системы после проявления неисправностей в технических средствах. 

Программа обслуживания (утилита) – программа, предназначенная для оказания услуг общего характера пользователям и обслуживающему персоналу. 

Управляющая программа совместно с набором необходимых для эксплуатации системы утилит составляют операционную систему.  

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

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

12.2. Использование командной строки 

В операционной системе Windows NT/XP/Vista параллельно с красочными графическими интерфейсами продолжает сохраняться интерфейс командной строки. Хотя пользователями он используется достаточно редко, системному администратору без него не обойтись. Чтобы вызвать командную строку, нужно нажать кнопку «Пуск», а затем  выбрать опцию «Выполнить». В раскрывшемся окне следует набрать cmd (командный процессор Windows) и щелкнуть на «Ok». Появится окно черного цвета с белыми буквами – интерфейс командной строки. На экране может быть написано следующее. 

C:\ Documents and Settings\ UserName > 

Это означает, что открыта папка «UserName», которая в свою очередь находится в папке «Documents and Settings», расположенной на диске «C». Знак «>» является приглашением к вводу команды. Если вы наберете команду «dir», а затем введете ее с помощью клавиши «Enter», то на экране появится список папок и файлов, находящихся в папке «UserName». Если хотите перейти в другой каталог, то нужно набрать команду «сd», а за ней указать путь, куда вы желаете перейти. Если вы решили ознакомиться со списком других внутренних команд процессора, то следует ввести команду «help». 

Большинство операционных систем, в том числе DOS и UNIX, позволяют передать программе, написанной на языке C++, при запуске один или несколько параметров. Они называются параметрами командной строки и разделяются при записи пробелами. Непосредственно в функцию main() эти параметры не передаются. Вместо них функция main() получает два других параметра. Один из них – это количество аргументов командной строки (целое число). По традиции он обозначается как argc (argument count – количество аргументов). Второй параметр – это массив указателей на символьные строки. Его обычно называют argv (argument vector – вектор аргумента). Имя запускаемой программы является первым аргументом, поэтому каждая программа имеет, по крайней мере, один аргумент. 

Общепринятым подходом является проверка аргумента argc, гарантирующая соответствие количества переданных и полученных аргументов. В листинге 12.1 показан пример использования аргументов командной строки. 

Листинг 12.1. Код программы «TestProgram» 

____________________________________________________________________ 

#include <iostream.h> 
int main(int argc, char *argv[]) 
{
cout<<«Received «<<argc<<» arguments…\n»; 
for (int i=0; i<argc; i++) 
cout<<«argument «<<i<<«: «<<argv[i]<<endl; 
return 0; 
} 

Этот код нужно запустить из командной строки. Предположим, что для файла исполняемой программы мы выбрали название: TestProgram.exe. Тогда требуется войти в ту папку, в которой размещается этот файл, и набрать после знака приглашения, например, следующее: 

TestProgram I am system programmer ! 

Получим следующий результат: 

Received 6 arguments… 
argument 0: TestProgram 
argument 1: I 
argument 2: am 
argument 3: system 
argument 4: programmer 
argument 5: ! 

Как можно видеть, элемент argv[0] – это имя программы, а первый аргумент командной строки – argv[1]. 

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

  1. С использованием библиотеки С. 
  2. С использованием Windows API. 
  3. С использованием вспомогательной функции Windows – CopyFile. 

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

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

12.3. Копирование файла с использованием стандартной библиотеки языка C 

Как видно из текста программы 12.2, стандартная библиотека С поддерживает объекты потоков ввода/вывода FILE, которые напоминают, несмотря на меньшую общность, объекты Windows HANDLE, представленные в программе 12.3. 

Листинг 12.2. Копирование файлов с использованием библиотеки С 

____________________________________________________________________ 

/* Программа копирования файлов cpC.  
   Реализация, использующая библиотеку C. */ 
/* срC file1 file2: Копировать файл1 в файл2. */ 
# include <iostream.h>  
# include <stdio.h>  
# include <errno.h>  
# define BUF_SIZE 256  
int main (int argc, char *argv []) 
{ 
FILE *in_file, *out_file;  
char rec [BUF_SIZE]; 
size_t bytes_in, bytes_out;  
if (argc != 3) { 
cout<< «Use: срС file1 file2\n»;  
return 1;  
} 
in_file = fopen (argv [1], «rb»);
if (in_file == NULL) {  
perror (argv [1]);  
return 2;  
} 
out_file = fopen (argv [2], «wb»); if (out_file == NULL) {  
perror (argv [2]);  
return 3;  
} 
/* Обработать входной файл по одной записи за один раз.*/  
while((bytes_in = fread (rec, 1, BUF_SIZE, in_file))>0) {  
bytes_out = fwrite (rec, 1, bytes_in, out_file);  
if (bytes_out != bytes_in) { 
perror («Неустранимая ошибка записи.»);  
return 4; 
} 
} 
fclose (in_file); 
fclose (out_file); 
return 0; 
} 

Предположим, что с помощью приведенной программы мы хотим содержание файла my.doc скопировать в файл my2.doc. Тогда в командной строке нужно набрать следующее 

cpC my.doc my2.doc 

Расширения имен файлов нужно указывать обязательно. Исполняемый файл должен иметь название cpC.exe. 

Этот простой пример может служить наглядной иллюстрацией ряда общепринятых допущений и соглашений программирования, которые не всегда применяются в Windows. 

  1. Объекты открытых файлов идентифицируются указателями на структуры FILE (в UNIX используются целочисленные дескрипторы файлов). Указателю NULL соответствует несуществующий объект. По сути, указатели являются разновидностью дескрипторов объектов открытых файлов. 
  2. В вызове функции fopen указывается, каким образом должен обрабатываться файл – как текстовый или как двоичный. В текстовых файлах содержатся специфические для каждой системы последовательности символов, используемых, например, для обозначения конца строки. Во многих системах, включая Windows, в процессе выполнения операций ввода/вывода каждая из таких последовательностей автоматически преобразуется в нулевой символ, который интерпретируется в языке С как метка конца строки, и наоборот. В нашем примере оба файла открываются как двоичные. 
  3. Диагностика ошибок реализуется с помощью функции perror, которая, в свою очередь, получает информацию относительно природы сбоя, возникающего при вызове функции fopen, из глобальной переменной errno. Вместо этого можно было бы воспользоваться функцией ferror, возвращающей код ошибки, ассоциированный не с системой, а с объектом FILE. 
  4. Функции fread и fwrite возвращают количество обработанных байтов, непосредственно, а не через аргумент, что оказывает существенное влияние на логику организации программы. Неотрицательное возвращаемое значение говорит об успешном выполнении операции чтения, тогда как нулевое – о попытке чтения метки конца файла. 
  5. Функция fclose может применяться лишь к объектам типа FILE (аналогичное утверждение справедливо и в отношении дескрипторов файлов UNIX). 
  6. Операции ввода/вывода осуществляются в синхронном режиме, то есть прежде чем программа сможет выполняться дальше, она должна дождаться завершения операции ввода/вывода. 

Преимуществом реализации, использующей библиотеку С, является ее переносимость на платформы UNIX, Windows, а также другие системы, которые поддерживают стандарт ANSI С. Кроме того, в том, что касается производительности, вариант, использующий функции ввода/вывода библиотеки С, ничуть не уступает другим вариантам реализации. Тем не менее, в этом случае программы вынуждены ограничиваться синхронными операциями ввода/вывода, хотя влияние этого ограничения будет несколько ослаблено использованием потоков Windows. 

Как и их эквиваленты в UNIX, программы, основанные на функциях для работы с файлами, входящих в библиотеку С, способны выполнять операции произвольного доступа к файлам (с использованием функции fseek или, в случае текстовых файлов, функций fsetpos и fgetpos), но это является уже потолком сложности для функций ввода/вывода стандартной библиотеки С, выше которого они подняться не могут. Вместе с тем, Visual C++ предоставляет нестандартные расширения, способные, например, поддерживать блокирование файлов. Наконец, библиотека С не позволяет управлять средствами защиты файлов. 

Резюмируя, можно сделать вывод, что если простой синхронный файловый или консольный ввод/вывод – это все, что вам надо, то для написания переносимых программ, которые будут выполняться под управлением Windows, следует использовать библиотеку С. 

12.4. Копирование файла с использованием Windows 

В программе 12.3 решается та же задача копирования файлов, но делается это с помощью Windows API. 

Листинг 12.3. Копирование файлов с использованием Windows API, первая реализация 

_____________________________________________________________________ 

/* Программа копирования файлов cpW.  
   Реализация, использующая Windows.*/ 
/* cpW file1 file2: Копировать файл1 в файл2.*/  
#include <windows.h>  
#include <stdio.h> 
#include <iostream.h> 
#define BUF_SIZE 256 
int main(int argc, LPTSTR argv[]) { 
HANDLE hIn, hOut;  
DWORD nIn, nOut;  
CHAR Buffer [BUF_SIZE];  
if(argc != 3) { 
cout<<«Use: cpW file1 file2\n»;  
return  1;  
}  
hIn = CreateFile(argv[1], GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);  
if (hIn==INVALID_HANDLE_VALUE) { 
cout<<«Невозможно открыть входной файл. Ошибка: %x\n», GetLastError ();  
return  2;  
}  
hOut = CreateFile (argv[2], GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);  
if(hOut==INVALID_HANDLE_VALUE) { 
cout<<«Невозможно открыть выходной файл. Ошибка: %x\n», GetLastError (); 
return 3;  
} 
while(ReadFile(hIn, Buffer, BUF_SIZE, &nIn, NULL)&&nIn > 0) {  
WriteFile (hOut, Buffer, nIn, &nOut, NULL);  
if (nIn != nOut) { 
cout<<«Неустранимая ошибка записи: %x\n», GetLastError (); 
return 4; 
} 
} 
CloseHandle (hIn);  
CloseHandle (hOut);  
return 0; 
}  

Этот пример иллюстрирует некоторые особенности программирования в среде Windows. 

  1. В программу всегда включается файл <windows.h>, в котором содержатся все необходимые определения функций и типов данных Windows. 
  2. Все объекты Windows идентифицируются переменными типа Handle, причем для большинства объектов можно использовать одну и ту же общую функцию CloseHandle. 
  3. Рекомендуется закрывать все ранее открытые дескрипторы, если в необходимость в них отпала, чтобы освободить ресурсы. В то же время, при завершении процессов относящиеся к ним дескрипторы автоматически закрываются ОС, и если не остается ни одного дескриптора, ссылающегося на какой-либо объект, то ОС уничтожает этот объект и освобождает соответствующие ресурсы. Как правило, файлы подобным способом не уничтожаются. 
  4. Windows определяет многочисленные символические константы и флаги. Обычно они имеют длинные имена, нередко поясняющие назначение данного объекта. В качестве типичного примера можно привести имена INVALID_HANDLE_VALUE и GENERIC_READ. 
  5. Функции ReadFile и WriteFile возвращают булевские значения, а не количества обработанных байтов, для передачи которых используются аргументы функций. Это определенным образом изменяет логику организации работы циклов. Нулевое значение счетчика байтов указывает на попытку чтения метки конца файла и не считается ошибкой. 
  6. Функция GetLastError позволяет получать в любой точке программы коды системных ошибок, представляемые значениями типа DWORD. В листинге 12.3 показано, как организовать вывод генерируемых Windows текстовых сообщений об ошибках. 
  7. Windows NT обладает более мощной системой защиты файлов, чем предшествующие ей версии. В данном примере защита выходного файла не обеспечивается. 
  8. Такие функции, как CreateFile, обладают богатым набором дополнительных параметров, но в данном примере использованы значения по умолчанию. 

12.5. Копирование файла с использованием вспомогательной функции Windows 

Для повышения удобства работы в Windows предусмотрено множество вспомогательных функций (convenience functions), которые, объединяя в себе несколько других функций, обеспечивают выполнение часто встречающихся задач программирования. В некоторых случаях использование этих функций может приводить к повышению производительности. Например, благодаря применению функции CopyFile значительно упрощается программа копирования файлов (листинг 12.4). Помимо всего прочего, это избавляет нас от необходимости заботиться о буфере, размер которого в двух предыдущих программах произвольно устанавливался равным 256. 

Листинг 12.4. Копирование файлов с использованием вспомогательной функции Windows 

___________________________________________________________________ 

/* Программа копирования файлов cpCF.  
 Реализация, в которой для повышения удобства 
 использования и производительности программы 
 используется функция Windows CopyFile. */ 
/* cpCF файл1 файл2: Копировать файл1 в файл2. */ 
#include <windows.h> #include <stdio.h> 
#include <iostream.h> 
int main (int argc, LPTSTR argv[]) { 
if (argc != 3) { 
cout<<«Use: cpCF file1 file2\n»;  
return 1; 
} 
if(!CopyFile (argv[1], argv[2], FALSE))  { 
cout<<«Ошибка при выполнении функции CopyFile:    %x\n», GetLastError (); 
return 2;  
}  
return  0; 
} 

12.6. О целесообразности использования стандартной библиотеки С 

В каких случаях при обработке файлов можно обойтись библиотекой С, а в каких необходимо использовать системные вызовы Windows? Тот же вопрос можно задать и в отношении использования потоков (streams) ввода/вывода C++ или системы ввода/вывода, которая предоставляется платформой .NET. Простых ответов на эти вопросы не существует, но если во главу угла поставить переносимость программ на платформы, отличные от Windows, то в тех случаях, когда приложению требуется только обработка файлов, а не, например, управление процессами или другие специфические возможности Windows, предпочтение следует отдавать библиотеке С и потокам ввода/вывода C++.  

К числу возможностей Windows, не поддерживаемых библиотекой С, относятся блокирование и отображение файлов (необходимое для разделения общих областей памяти), асинхронный ввод/вывод, произвольный доступ к файлам чрезвычайно крупных размеров (4 Гбайт и выше) и взаимодействие между процессами. 

© Copyright 2020, All Rights Reserved