Запуск из приложения внешних программ

Функции объявлены в файлах process.h, stdlib.h, stdio.h

int execl(char *path, char *arg0, *argl,..., *argn, NULL) ‑ выполняет порожденный процесс path с аргу­ментами arg0 - argn.

int execle(char *path, char *arg0, *argl,..., *argn, NULL, char **env - вы­пол­няет порожденный процесс path с аргументами arg0 - argn и с окружением env.

int execlp(char *path, char *arg0,*argl,..., *argn, NULL) ‑ выполняет порожденный процесс path с аргу­ментами arg0 ‑ argn, с поиском в PATH.

Пример вызова редактора Word:

execlp («Winword», «Winword», «Delphi.doc»,NULL)

int execlpe(char *path, char *arg0, *argl,..., *argn, NULL, char **env) - вы­пол­няет порожденный процесс path с аргу­ментами arg0 ‑ argn, с поиском в PATH и с окружением env.

int execv(char *path, char *argv[]) ‑ выполняет порожденный процесс path с аргу­ментами argv[].

int execvp(char *path, char *argv[]) ‑ выполняет порожденный процесс path с аргу­ментами argv[], с поиском в PATH.

int system(const char *command) ‑ выполняет команду command опе­ра­цион­ной системы и возвращается в приложение.

 

Работа с файлами

Файлы в С

Состав файла задается структурой FILE. В начале работы стан­дарт­ный файл ввода stdin приписывается клавиа­туре, а стандартный файл вы­во­да stdout - экрану дисплея. Перед обработкой файла он объявляется и затем открывается, а пос­ле обработки ‑ закрывается.

Файлы бывают следующих типов:

текстовый ‑ состоит из последовательности сим­волов, разбитой на стро­ки. Для деления на строки используется управляющий символ ‘\n’. Для работы с текстовыми файлами удобно работать специальными методами загрузки (LoadFromFile) и сохранения (SaveToFile);

двоичный - это последовательность значений типа char.

Символ EOF в операциях ввода/вывода служит для обозначения и проверки конца файла или возникновения ошибки ввода/вывода.

Функции открытия и закрытия файлов

FILE *fopen(char *filename, char *type) - открытие файла. В качестве пер­вого аргумента передается имя файла.

Второй аргумент определяет тип открываемого файла:

r - открыть уже существующий файл на ввод;

w - создать новый файл или очистить уже существующий файл и открыть его на вывод;

а - создать новый файл для вывода или осуществить вывод в конец уже существующего файла;

r+ - открыть существующий файл для обновления с начала файла;

w+ - создать новый или очистить существующий файл для обновления его со­держимого;

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

Дополнительно к каждой из приведенных строк можно добавить символ

b - открывается двоичный файл.

Функция fopen возвращает указатель (файловая переменная) на структуру FILE, описывающую файл. Если при открытии файла произош­ли какие-либо ошибки, то в глобальную переменную еrrnо будет записан код (номер) ошибки, и будет возвра­щен нулевой (0) указатель.

int fclose (FILE *file) - файл закрывается. Если за­крытие выполняется правильно, то возвращается 0, иначе ‑ EOF;

void rewind (FILE *file) ‑ указатель файла перемещается в начало файла.

Функции ввода

Int fgetc(FILE *file) -из указанного входного файла считывается очеред­ной символ, и его значение перево­дится в тип int. Если при считывании обна­ружи­вает­ся ошибка или достигается конец файла, то возвращается значение EOF.

Int getchar() -из стандартного входного файла stdin считывается очеред­ной символ, и его значение пере­водится в тип int.

Int getch() - аналогична getchar, но не требует нажатия клавиши после вво­да символа и останавливает работу программы до нажатия клавиши. Эта функция используется для ввода односимволь­ного ответа.

int fseek(FILE *file, long offset, Int wherefrom) -служит для произволь­ного доступа к символам, обычно внутри двоичных файлов. Первый аргумент задает имя файла Второй аргумент offset является длинным целым числом со знаком и указывает число байтов смещения от точки, определяемой третьим параметром функции. Третий аргумент wherefrom указывает точку, от ко­торой следует начинать отсчет смещения: от нача­ла файла (0), текущей позиции файла (1), от конца файла (2).

char *fgets(char *s, Int n, FILE *file) -в строку s считываются символы до тех пор, пока не будет выполнено первым одно из условий: начнется новая строка, достигнут конец файла или прочитано n-1 символов. После того как из входного файла в строку s бу­дут прочитаны символы, строка до­пол­няется ноль‑символом (признак конца строки). Если операция счи­ты­ва­ния прошла успешно, то возвращается адрес строки s, иначе ‑ нуль.

char *gets(char *s) -выполняется считывание сим­волов из стандартного входного файла stdin. Если вход­ной файл прерывается символом перехода на новую строку ‘ \n ’, то этот символ не попадает в строку s.

Int fread(void *ptr, unsigned elem_size, int count, FILE *file) -из входного файла считыва­ются и по адресу *ptr записываются не более чем количест­во count элементов размером elem_size байтов каждый. Функция возвра­щает число фактически считанных элементов.

Int feof(FILE *file) -если при чтении из указанного файла достигнут конец файла (попытка прочитать символ за пределами файла), то возвра­щает­ся ненулевое значение, иначе - нулевое значение.

int scanf Ошибка! Закладка не определена. (char *fornat, <дополнительные аргументы>);

int fscanf(FILE *strea», char *format,< дополнительные аргументы>);

int sscanf(char *string, char *fогmаt,< дополнительные аргументы>);

int cscanf(char *format, <дополнительные аргументы>);

Все функции семейства scanf вводят поля символ за символом, переводя их в соответствии с указанным форма­том. Функцией scanf осуществляется ввод из стандартного файла stdin. Функция fscanf может вводить из файла, указанного пользователем. Фун­кция sscanf вводит из заданной строки. Функция cscanf вводит с кон­соли. Первое.вводимое поле преобразуется в соответствии со спецификацией формата, и полу­ченное значение заносится по адресу первого аргумента. Следующее поле переводится в соответ­ст­вии со второй спецификацией фор­мата и т.д. Спецификация формата аналогична спецификации формата для семейства функций printf (п. 6.2.4).

Поля ввода определяются по следующим правилам:

группа символов до (но не включая) символа - раз­делителя;

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

группа из n символов, где n - указатель ширины по­ля.

Функции вывода

Int fflush(FILE *file) -служит для выталкивания каждого внутреннего бу­­фера на соответствующее устройство. После вызова функции файл остается открытым. Если при выполнении функции появятся ошибки, то будет возвращено значение EOF, иначе - 0.

Int fputc(char ch, FILE *file) - символ ch записывается в указанный выход­ной файл. Если запись прошла успешно, то возвращается значение ch.

int putchar(char ch) -действует аналогично функции fputc, но записывает символ ch в стандартный выходной файл stdout.

Int fputs(char *s, FILE *file) -строка s, ограниченная ноль-символом, переписывается в выходной файл, причем ноль-символ отбрасывается. Если при переписи возникает ошибка, то возвращается значе­ние EOF, в противном случае возвращается ненулевое зна­чение.

Int puts(char *s) -функция аналогична функции fputs, за исключением того, что символы переписываются в стандартный файл stdout, и строка s дополняется ноль‑символом конца строки.

Int fwrite(void *ptr, unsigned elem_size,Int count,FILE <stream>) -начиная с адреса ptr, считывается не более чем количество count элементов размером elem_size байтов каждый, и эти элементы записываются в вы­ход­ной файл. Функция возвращает число фактически записанных элементов.

Int fprintf(FILE *stream,char *format,< список выводимых значений>);

Int printf(char *format,<список выводимых значений>);

Int sprintf(char *s, char *foramt, < список выводимых значений>);

Int cprintf(char *format, < список выводимых значений>);

С помощью этих функций выполняется форматный вывод соот­ветственно в: выход­ной файл (fprintf), в стандартный выходной файл stdout (fprintf), ука­зан­ную строку (sprintf) или на терминал (cprintf). Функции возвращают число символов, переданных по назначе­нию.

Строка формата (char *format) задает редактирование данных (п. 6.2.5).

Функции обработки ошибок

Int ferror(FILE *file) -возвращает нулевое значение, если последняя операция ввода/вывода с указанным файлом закончилась успешно, иначе ‑ нену­ле­вое значение.

void clearerr(FILE *file) -устанавливается в нуль состояние признака ошибки в указанном файле.

Пример программы создания справочника товара spravtov.txt

int main(int argc, char **argv) // основная функция

{ struct {int kt; char nt [20];} zstovar; // объявление переменной-записи

FILE *nf; // объявление файловой переменной nf*

if ((nf=fopen(«spravtov.txt»,»w»))==0) // проверка открытия spravtov.txt

{puts («Ошибка при открытии файла spravtov.txt»); return EOF;} // выход while (1) // начало бесконечного цикла ввода данных

{printf(«\nКод товара(0-выход)?»); scanf(«%d»,&zstovar.kt); // ввод if (zstovar.kt<=0||zstovar.kt>10) break; // выход из цикла ввода

printf(«\n Название товара?»); scanf(«%s»,&zstovar.nt); // ввод fseek(nf,(zstovar.kt-1)*sizeof(zstovar),0);// установка на запись с номером=kt

fwrite(&zstovar,sizeof(zstovar),1,nf); // вывод записи zstovar в файл spravtov

} /* конец тела цикла */ fclose(nf); // закрытие файла spravtov.txt

} // конец тела основной функции

6.5.2. Файлы в С++

При работе с файлами (#include <fstream.h>) используются поточные клас­сы ifstream (чте­ние), ofstream (запись), fstream (чтение и запись). Описание потоков приводится в файле Cbuilder5 \ Help\IOS&CR.DOC.

Перед открытием файла следует создать поточный объект в виде: <имя класса> <имя объекта>. В консольных при­ло­жениях поточные объекты под именами cout и cin задают стандартный вы­вод на экран и ввод с клавиатуры и не требуют сво­его создания, откры­тия и закрытия и могут быть переопределены в коман­д­ной строке на файлы. Открытие файла выполняется отдельно методом open (<имя файла>,<режимы>) или сразу при создании поточного объекта (ofstream file(«Tovari.txt»);).

Режимы задаются в виде: ios:: <режим>| ios:: <режим>| ios:: <режим>...

Перечислим основные режимы: in (ввод), out (вывод), binary (бинарный файл), app (дозапись в конец файла), ate (установить указатель в конец файла), trunc (очистка файла).

Пример открытия файла на запись и его закрытия:

ofstream file; file.open(«Tovari.txt», ios::out|ios::app); file.close();

Операторы включения (<<) и извлечения (>>) записывают и чи­тают данные из файла. Опера­тор извлечения останавливается на первом символе-разделителе (сим­волы про­бела, табуляции и новой строки). Таким образом нельзя ввести зна­че­ние из нескольких слов в отличие от мето­да getline. В данных опе­раторах можно использовать модификаторы для форматирования дан­ных (#include <iomanip.h>): endl/ends (вставка символа новой/конца строки), dec/hex/oct (перевод в десятич­ное/шес­т­над­цати­рич­ное/вось­меричное чис­ло), ws (извлечение про­белов), flush (очистка ost­ream), setfill(‘<символ>’) (установка символа заполните­ля), setprecision(n) (точ­ность вещественных чисел в n разрядов), setw(n) (ши­рина поля n).

Основные методы класса ofstream: open (открытие), put (запись сим­вола), write (запись заданного числа символов), seekp (установка ука­за­те­ля на нужный байт), tellp (возвращает значение указателя), close (за­кры­тие). Основные методы класса ifstream: open (открытие), get (чтение), getline (чтение строки), read (чтение заданного числа байтов), eof (true, достигнут конец файла), peek (выдает очередной символ, но не выбирает его), seekg (установка указателя на нужный байт), tellg (возвращает значение указателя), close (закрытие).

Пример создания текстового файла «Tovari.txt»:

int main(int argc, char **argv) {

ofstream file («Tovari.txt»); //создание объекта file и открытие файла

file << «мука рисовая» << endl << 1 << endl << 5.4 << endl; // вывод в файл

file <<«сахар тростниковый»<<endl<<2<<endl<<10.1<<endl;//вывод в файл

file.close(); /* закрытие файла*/ }

Пример чтения текстового файла «Tovari.txt»:

int main(int argc, char **argv) {

ifstream file(«Tovari.txt»); // создание объекта file и открытие файла

if (!file) return EOF; // ошибка при открытии файла

char nt[40]; int kod=0, i=0; float cena; // объявление переменных

while (!file.getline(nt,sizeof(nt)).eof()) // цикл чтения файла

{file>>kod>>cena>>ws;//чтение в переменные kod и cena, пропуск пробелов

cout << nt << endl << kod <<endl << cena << endl; // вывод на экран

}file.close(); getch(); /* закрытие файла*/ }

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

Пример программы создания справочника товара spravtov (п.6.5.1):

int main(int argc, char **argv) {

struct {int kt; char nt [20];} zstovar; // объявление переменной-записи

ofstream file(«spravtov.txt»,ios::binary); // создание объекта file и открытие

if (!file) {puts («Ошибка при открытии файла spravtov.txt»); return EOF;} while (1) // начало бесконечного цикла ввода данных

{cout <<«\nКод товара(0-выход)?»; cin >> zstovar.kt; // ввод код товара в kt

if (zstovar.kt<=0 || zstovar.kt>10) break; // выход из цикла ввода

cout << «Название товара? «; cin >> zstovar.nt; // ввод наименования товара

file.write((char*)&zstovar,sizeof(zstovar)); // вывод записи zstovar в spravtov

} /* конец тела цикла */ file.close(); // закрытие файла spravtov.txt

ifstream infile(«spravtov.txt»,ios::binary); // открытие файла для чтения

while(!infile.read((char*)&zstovar,sizeof(zstovar)).eof())//цикл чтения записей

cout << zstovar.kt << ««<< zstovar.nt << endl; // вывод полей kt и nt

infile.close(); getch(); /* закрытие файла spravtov.txt */ }

Произвольный доступ к файлу осуществляется методом seekg (при чтении записи) или метод seekp (при замене записи) с параметром, ко­то­рый указывает порядковый номер байта устанавливаемой позиции (указателя) фай­­ла (отсчет начинается с нуля). Следующие методы чтения / за­писи будут читать/записывать, начиная с этой позиции файла.

Пример чтения записи под номером 2 из файла spravtov.txt:

int main(int argc, char **argv) {

struct {int kt; char nt [20];} zstovar; // объявление переменной-записи

ifstream infile(«spravtov.txt»,ios::binary); // открытие файла для чтения

infile.seekg(1*sizeof(zstovar));//установка указателя на начало 2-й записи

infile.read((char*)&zstovar,sizeof(zstovar)); // чтение второй записи

cout << zstovar.kt << ««<< zstovar.nt << endl; // вывод полей kt и nt 2-й зап.

infile.close(); getch(); /* закрытие файла spravtov.txt */ }

6.5.3. Файлы в С++Builder

Для ввода/вывода файлов используется компонентный класс TFileStream, который частично включает в себя поточные классы С++. Поэ­тому эти два способа работы с файлами совместимы (методы С++ бо­лее быстрые при работе). Достоинством класса TFileStream является ис­поль­зование механизма исключения для обработки ошибок ввода/выво­да.

Основые свойства класса TFileStream: Position (текущее значение позиции файла; оно доступно для чтения и записи), Size (размер файла).

Основые методы класса TFileStream: TFileStream (конструктор открывает файл в нужном режиме), CopyFrom (копирует заданное число бай­тов из другого потока в данный), Read/Write (вводит/выводит заданное чис­ло байтов и возвращает число фактически введенных/выведенных сим­во­лов), Seek (перемещает указатель файла в нужную позицию отно­си­тельно начала, конца или текущего указателя файла), delete (закры­ва­ет файл). Открытие файла осуществляется в виде:

TFileStream* <имя объекта> = new TFileStream(<имя файла>,<режимы>);

Режимы открытия файла: FmCreate (создание файла; если он уже су­щест­вует, то открыть его для записи), fmOpen­Read (открыть файл для чтения), fmOpenWrite (открыть файл для записи с полной заменой теку­ще­го содер­жа­ния), fmShareExclusive/fmShareDeny­No­ne (монопольное/кол­лек­тив­ное ис­поль­зование файла), fmShareDenyWrite/fmShareDenyRead (ко­л­­­лективное использование фай­ла по чтению/записи).

Пример. Разместим на форме кнопку Button1 и объект Memo1. Сос­тавим процедуру обработки события Click для этой кнопки:

void __fastcall TForm1::Button1Click(TObject *Sender) // процедура

{ struct stovar{int kt; char nt [20];} zstovar; // объявление переменной-записи

char str[30]; // создадим далее объект file и откроем создаваемый файл

TFileStream* file = new TFileStream(«spravtov.txt»,fmCreate); // открытие

stovar zst1={1, «масло крестьянское»}; // значения полей первой записи zst1

stovar zst2={2, «масло подсолнечное»};// значения полей второй записи zst2

file->Position=(zst1.kt-1)*sizeof(zst1); // установка на запись под номером kt

file->Write(&zst1,sizeof(zst1));//вывод записи zst1 под номером kt в spravtov

file->Position=(zst2.kt-1)*sizeof(zst2); // установка на запись под номером kt

file->Write(&zst2,sizeof(zst2));//вывод записи zst2 под номером kt в spravtov

delete file; // удаление объекта file c закрытием файла spravtov.txt

//создание объекта infile и открытие файла spravtov.txt для чтения

TFileStream* infile = new TFileStream(«spravtov.txt»,fmOpenRead);

Memo1->Clear(); // очистка объекта Memo1

while(infile->Read(&zstovar,sizeof(zstovar))>0) // цикл чтения записей

{ sprintf(str,»код: %d товар: %s»,zstovar.kt,zstovar.nt); // формирование str

Memo1->Lines->Add(str); // добавление строки str в массив строк Memo1

}delete infile; /*удаление объекта infile c закрытием файла spravtov.txt*/ }

6.6. Объектно‑ориентированное программирование

Создание классов и объектов

Оператор объявления класса имеет вид:

class <имя класса>: [<режим доступа>] <имя родительского класса>

{ [ private: <поля, методы, свойства и события, доступные только в классе>]

[ protected: <аналогичен private, и дополнительно доступный потомкам>]

[ public: <поля, методы, свойства и события, доступные всем >]

[ _published: <аналогичен public и изменяемый в Инспекторе Объектов>]

[ friend <дружественные функции>]

}; //окончание объявления класса

Режим доступа задается словами: private /public (защищенные имена остаются защищенными, а общедоступные имена родительского класса недоступны/доступны в производном классе).

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

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

Объект объявляется в разделе переменных оператором вида:

<имя класса> <имя объекта>;

Доступ к полям, свойствам и методам объекта реализуется указа­нием имени объекта, стрелочки (->) и имени поля, свойства или метода.

Пример задания значения свойству Caption объекта Button1:

Button1->Caption:=«Выход»; //надпись командной кнопки «Выход»

Конструктор/деструктор ‑ специальные методы, создающие/ун­ич­тожающие объекты. Они отличаются от обычных методов следующими осо­бенностями: имеют имя, совпадающее с именем своего класса (у дес­трук­­тора перед именем указывается символ тильда «~»); автоматически вы­зы­вают­ся компилятором; не имеют возвращаемого зна­че­ния, не могут нас­ле­до­вать­ся, хотя могут вызываться из производного класса; по умол­ча­нию имеют атрибут public; конструкторы не могут быть виртуальными.

Конструкторы бывают трех типов:

конструктор по умолчанию не имеет параметров, и при его явном отсут­ст­вии в классе создается автоматически компилятором;

конструктор с параметрами позволяет в момент создания объекта вы­зы­вать различные функции и передавать им значения через параметры;

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

Операция доступа к области действия (::) задается в виде:

:: <имя глобальной переменной> или <имя класса> :: <имя функции>

Первая форма позволяет обратиться к глобальной переменной, если она даже закрыта одноименой локальной переменной (::x:=12.6).

Вторая форма обозначает, что функция, хотя и определена вне ука­зан­ного класса, является методом данного класса и существует в области дей­ствия этого класса (TForm1::Button1Click(TObject *Sender)).

Пример создания и использования классов: Circle (вывод данных о круге) и производного из него класса Cylinder (вывод данных о цилиндре).

const double pi=3.14159265358979; // объявление константы pi

class Circle // объявление класса Circle ‑ вывода радиуса и площади круга

{ protected: double r; // объявление переменной со значением радиуса круга

public: // общедоступные методы и переменные класса Circle

Circle(double rVal=0) // заголовок конструктора класса с параметром rVal

: r(rVal) // при создании объекта Circle значению r присваивается rVal

{ } // пустое тело метода; можно было и так: Circle(double rVal=0){r=rVal;}

void setRadius(double rVal) {r=rVal;} // метод установки значения r

double getRadius() {return r;} // метод возвращения значения радиуса r

double Area() {return pi*r*r;} // метод вычисления площади круга

void showData(); // объявление метода вывода данных о круге

}; // окончание объявления класса Circle

// объявление производного класса Cylinder из класса Circle

class Cylinder: public Circle // класс Cylinder выводит данные о цилиндре

{protected:double h; //объявление переменной h‑значение высоты цилиндра

public: // общедоступные методы и переменные класса Cylinder

Cylinder (double hVal=0, double rVal=0) // заголовок конструктора класса

: h(hVal), // при создании объекта Cylinder значению h присваивается hVal

Circle(rVal){ } // вызов конструктором класса Cylinder конструктора Circle

void setHeight(double hVal) {h=hVal;} // метод установки значения h

double getHeight () {return h;} // метод, возвращающий значение h

// метод вычисления поверхности цилиндра. Circle::Area() перезагружает

//унаследованную функцию класса Circle для вычиcления площади

//основания цилиндра.

double Area() {return 2*Circle::Area()+2*pi*r*h;} // площадь цилиндра

void showData(); // объявление метода вывода данных о цилиндре

}; // окончание объявления класса Cylinder

void Circle::showData() // заголовок метода в Circle вывода данных о круге

{cout << «Радиус круга = «<<getRadius()<<endl // вывод значения радиуса

<< «Площадь круга = «<< Area()<<endl <<endl; // вывод площади круга

} // конец метода Circle::showData

void Cylinder::showData() // метод в Cylinderвывода данных о цилиндре

{cout << «Радиус основания = «<< getRadius() << endl // вывод радиуса

<< «Высота цилиндра = «<< getHeight() << endl // вывод высоты

<< «Площадь поверхности=«<< Area() << endl; // вывод площади

} // конец метода Cylinder::showData

int main(int argc,char **argv) // основная процедура тестирования классов

{Circle circle(4); // создания объекта circle класса Circle (круг радиусом 4)

Cylinder cylinder(9,3); //создания объекта cylinder класса Сylinder (цилиндр)

circle.showData(); // вывод данных о круге методом showData класса circle

cylinder.showData(); // вывод данных о цилиндре методом cylinder.showData

getch(); return 0; // остановка и завершение работы функции

} // конец функции тестирования классов и объектов

Виртуальные методы

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

Пример виртульного метода и позднего его связывания:

class Parent // объявление родительского класса Parent

{ public: // общедоступные методы и переменные класса Parent

virtual double Fun1(double x) {return x*x;} // виртуальный метод Fun1

double Fun2(double x) {return Fun1(x)/4;} // обычный метод Fun2

}; // окончание объявления класса Parent

class Child: public Parent // объявление потомка Parent из класса Child

{public: // общедоступные методы и переменные класса Child

virtual double Fun1(double x) {return x*x*x;} // виртуальный метод Fun1

}; // окончание объявления класса Child

int main(int argc, char **argv) // основная процедура тестирования классов

{ Child child; // создания объекта child класса Child

// Вывод значения функции, наследуемой из родительского класса Parent

// Fun2(4), которая в свою очередь вызовет переопределенную виртуаль­//ную функцию Fun1 потомка Child (Child::Fun1), а не родительскую //функцию Fun1 (Parent::Fun1).

cout << child.Fun2(4) << endl; // вывод значения 16

getch(); return 0; // задержка и завершение работы функции тестирования

} // конец функции тестирования

Дружественные функции

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

FriendreturnType <имя функции> ( <параметры> ). Оператор вызова функ­ции имеет вид: <имя функции> (& <имя экземпляра класса с функцией> ).

Шаблоны

Шаблоны позволяют создавать семейство функций или классов:

Template< список шаблонных типов > { <объявление> };

Шаблон функций задает образец объявлений перегруженных фун­кций (типы аргу­ментов и результатов работы функции могут меняться при ее различных вызовах) (п. 6.2.7). Фактичес­кие типы должны быть известны во время компиляции.

Пример шаблона функцииmaxim (нахождение наиболь­ше­го числа из двух чисел, все аргументы и результат имеют пе­ре­менный тип T):

template <class T> T maxim (T x,T y) // шаблон функции maxim

{ return (x > y)? x: y;} // тело функции maxim

int main(int argc, char **argv) // основная функция проверки шаблона

{ int i=2; int j=maxim(i,0); // аргументы функции maxim типа int

float a=3.2,b=8.6;float m=maxim(a,b); //аргументы функции maxim типа float

cout << j << endl; cout << m <<endl; getch(); return 0; // вывод результатов

} // конец функции

Шаблон классов задает образец определений семейства классов.

Пример шаблона Vector ‑ генератор классов одномерных массивов.

template <class T> class Vector;

Пространство имен

Механизм пространства внешних (глобальных) имен позволяет раз­бить приложе­ние на отдельные пространства, в каждом из которых можно определить свои глобальные иден­тификато­ры. Последние не зависят от других прост­ранств. Каждое пространство начинается со строки:

namespace <идентификатор подсистемы> { [<объявления>] }.

Существуют три способа доступа к элементам подсистем:

1. Явная в виде <имя подсистемы> :: <переменная, функция> (first::nds).

2. Доступ ко всем элементам в виде using namespace:: <имя подсистемы> (using namespace:: first).

3. Объявление нового идентификатора в локальном пространстве имен в ви­де: using:: <новое имя> (using:: nds;).

Пример:

namespace first { int i=10, j=11; } // объявление пространства first

int main(int argc, char **argv) // основная функция тестирования

{ cout << first::i << endl; // вывод переменной i=10 из пространства first

using namespace:: first; // доступ ко всем переменным пространства first

cout << j << endl; // вывод переменной j=11 из пространства first

getch(); return 0; // задержка и выход из функции

} // конец тела основной функции