Файл: Информация и формы ее представления Информационные процессы и технологии.docx

char Symb=fgetc(fin);

Если при обработке достигается конец файла, то функция fgetc() возвращает значение EOF(end of file).

Функция fputc() заносит значение символа Symb в файл, на который указывает указатель out. Формат вызова функции:

f putc(Symb,out);

Пример 1. Текст из файла my_char.txtвыводится на экран. Если файл не найден, на экран выводится сообщение "File not found!":

#include "stdafx.h"

int main()

{

FILE *ptr; //описание указателя на файл

char ch;

if ((ptr=fopen("my_char.txt","r"))!=NULL)/*открытие файла для чтения*/

{

ch=fgetc(ptr); //чтение первого символа из файла

while (!feof(ptr)) //цикл пока не достигнут конец файла

{

printf("%c",ch); //вывод символа, взятого из файла

ch=fgetc(ptr); //чтение следующего символа из файла

}

fclose(ptr); //закрытие файла

}

else printf("\nFile not found!");

return 0;

}
В этом примере для чтения файла используется указатель ptr. При открытии файла производится проверка. Если переменной ptr присвоено значение NULL, то файл не найден; на экран выводится соответствующее сообщение, и программа завершается. Если ptr получил ненулевое значение, то файл открыт. Далее выполняется чтение символов из файла до тех пор, пока не будет достигнут конец файла (!feof(ptr)). Прочитанный символ помещается в переменную ch, а затем выводится на экран.

Пример 2. Записать в файл буквы, вводимые с клавиатуры. Ввод продолжается до нажатия клавиши F6 или CTRL/z (ввод символа EOF – конца файла):

#include "stdafx.h"

int main(void)

{

char c;

FILE *out; // описание указателя на файл

out=fopen("Liter.txt","w"); //открытие файла для записи

while ( (c=getchar( ))!=EOF) /*пока не будет введен символ конца */

fputc(c,out); // запись введенного символа в файл

fclose(out); //закрытие файла

return 0;

}

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

Рассмотрим пример:

fgets(string, n, fp);

Функция возвращает указатель на строку string при успешном завершении и константу NULL в случае ошибки либо достижения конца файла.

Функция fputs() записывает строку символов в файл. Она отличается от функции puts() тем, что в качестве второго параметра должен быть записан указатель на переменную файлового типа.

Например:

fputs("Ехаmple", fp);

При возникновении ошибки возвращается значение EOF.

Пример 3. Имеется текстовый файл. Определить длины строк этого файла:

#include

#include
int _tmain(int argc, _TCHAR* argv[])

{

setlocale(0,"RUS");

char st[125];

int a=0;

FILE *fo;

fo = fopen("prim.txt","r"); //открытие файла для чтения

while (!feof(fo))//цикл пока не конец файла

{

fgets(st,125,fo); //читать строку символов

if (!feof(fo)) //если не конец файла

{

a=strlen(st); //определить длину строки

printf("Длина:%d строка:%s \n",a,st);

}

}

fclose(fo);

return 0;

}

Функции fscanf() и fprintf() выполняют форматированный ввод/вывод.
Чтение из файла выполняет функция fscanf():

fscanf(fin,["строка формата"],[список адресов переменных]);

Функция возвращает количество введенных из файла значений или EOF.

Запись в файл осуществляет функция fprintf():

fprintf(out,["строка формата"],[список переменных, констант]);

Возвращает количество выведенных в файл байт (символов) или EOF.

Строка формата функций fscanf() и fprintf() формируется так же, как было описано ранее в главе, посвященной консольному вводу/выводу и функциям printf() и scanf().

Следует заметить, что вызов функции

fscanf(stdin,[строка формата],[список адресов переменных]);

эквивалентен вызову

scanf([строка формата],[список адресов переменных]);

Аналогично,

fprintf(stdout, [строка формата],[список переменных, констант]);

эквивалентно

printf([строка формата],[список переменных, констант]);

Рассмотрим примеры программ, использующих эти функции.

Пример 4. В программе создается массив, состоящий из четырех целых чисел. Вывести массив в файл:

#include "stdafx.h"

#define n 4

int main()

{

int i=0;

int array[n]={4,44,446,4466}; /*описание и инициализация масcива */

FILE *out; //описание указателя на файл

out=fopen("num_arr.txt","w"); //открытие файла для записи

for(;i
fprintf(out, "%6d",array[i]); //запись в файл элемента массива

fclose(out); //закрытие файла

return 0;

}

В результате выполнения программы в файл num_arr.txt будет помещена следующая информация:

0	4	4	4	4	4	6	4	4	6	6

Пример 5. Имеется файл данных, содержащий целые числа, разделенные пробелами. Количество чисел в файле неизвестно. Требуется найти среднее арифметическое значение этих чисел:

#include "stdafx.h"

int main()

{

int S=0, count=0, numb; //описание переменных

FILE *in; //описание укателя на файл

if((in=fopen("num_arr.txt","r"))!=NULL)/*открытие файла для чтения*/

{

while (!feof(in)) //цикл пока не конец файла

{

fscanf(in,"%d",&numb); //читать из файла число в переменную numb

S+=numb; // добавить numb в сумму

count++; //увеличиваем счетчик на 1

printf("%d\n", numb); //выводим значение numb на экран

}

double aver=(double)S/count; //считаем среднее значение

printf("Average=%lf\n", aver); //вывод среднего значения

fclose(in); //закрыть файл

}

else

printf("\nФайл не найден!");

return 0;

}

Чтение чисел из файла выполняется в переменную numb до тех пор, пока не будет достигнут конец файла. Одновременно ведется подсчет количества прочитанных чисел в переменной count и накопление суммы прочитанных чисел в переменной S. Переменные S и count целые, поэтому для правильного вычисления среднего арифметического, необходимо выполнить преобразование одной из этих переменных в формат double.

Функция fread() предназначена для чтения блоков данных из потока. Имеет прототип:

unsigned fread(void *ptr,unsigned size,unsigned n,FILE *fp);

Она читает n элементов данных, длиной size байт каждый, из заданного входного потока fp в блок, на который указывает указатель ptr. Общее число прочитанных байтов равно произведению n*size. При успешном завершении функция fread() возвращает число прочитанных элементов данных, при ошибке - 0.

Функция fwrite() предназначена для записи в файл блоков данных. Имеет прототип:

unsigned fwrite(void *ptr,unsigned size,unsigned n,FILE *fp);

Она добавляет n элементов данных, длиной size байт каждый, в заданный выходной файл fp. Данные записываются с позиции, на которую указывает указатель ptr. При успешном завершении операции функция fwrite() возвращает число записанных элементов данных, при ошибке - неверное число элементов данных.

Примеры использования функций fread()и fwrite() будут приведены позже при рассмотрении работы с бинарными файлами.

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

1. Функции fseek( )и ftell().

Несмотря на то, что указатель позиции в файле перемещается автоматически, в языке С++ имеются функции fseek() и ftell(), позволяющие программно управлять положением позиции в файле.

Функция ftell() возвращает значение указателя текущей позиции файла.

Функция fseek() устанавливает указатель в позиция файла в соответствии со значениями своих параметров.

Синтаксис данных функций следующий:

int fseek( FILE *stream, long offset, int origin );
long ftell( FILE *stream );

где *stream – указатель на файл; offset – смещение позиции в файле (в байтах); origin – флаг начального отсчета, который может принимать значения: SEEK_END – конец файла, SEEK_SET – начало файла; SEEK_CUR – текущая позиция. Последняя функция возвращает номер текущей позиции в файле.

Пример 6. Рассмотрим действие данных функций на примере считывания символов из файла в обратном порядке.
#include "stdafx.h"

#include

int main(void)
{
FILE *fp=fopen("my_file.txt","w"); //открытие файла для записи
if(fp != NULL)
{
fprintf(fp,"It is an example using fseek and ftell functions."); //запись в файл текста
}
fclose(fp); //закрытие файла
fp = fopen("my_file.txt","r"); //открытие файла для чтения
if(fp != NULL)
{
char ch;
fseek(fp,0L,SEEK_END); //указатель перемещен в конец файла
long length = ftell(fp);//определение размера файла
printf("length = %ld\n",length);
for(int i = 1;i <= length;i++) //цикл для чтения
{
fseek(fp,-i,SEEK_END); //перемещение на нужную позицию
ch = getc(fp);
putchar(ch);
}
}
fclose(fp);
return 0;
}

В данном примере сначала создается файл, в который записывается строка “It is an example using fseek and ftell functions.”. Затем этот файл открывается на чтение и с помощью функции fseek(fp,0L,SEEK_END) указатель позиции помещается в конец файла. Это достигается за счет установки флага SEEK_END, который перемещает позицию в конец файла при нулевом смещении. В результате функция ftell(fp) возвратит число символов в открытом файле. В цикле функция fseek(fp,-i,SEEK_END) смещает указатель позиции на –i символов относительно конца файла, после чего считывается символ функцией getc(), стоящий на i-й позиции с конца. Так как переменная i пробегает значения от 1 до length, то на экран будут выведены символы из файла в обратном порядке.

2. Функция ferror() позволяет проверить правильность выполнения последней операции при работе с файлами. Имеет следующий прототип:

int ferror(FILE *fp);

В случае ошибки возвращается ненулевое значение, в противном случае возвращается нуль.

3. Функция remove() удаляет файл и имеет следующий прототип:

int remove(char *file_name);

Здесь file_name - указатель на строку со спецификацией файла. При успешном завершении возвращается нуль, в противном случае возвращается ненулевое значение.

4. Функция rewind( ) устанавливает указатель текущей позиции в начало файла и имеет следующий прототип:

void rewind(FILE *fp);

Работа с текстовыми файлами

Файлы бывают текстовые (в которых можно записывать только буквы, цифры, скобки и т.п.) и двоичные (в которых могут храниться любые символы из таблицы). В текстовых файлах не употребляются первые 31 символ кодовой таблицы ASCII (управляющие), а символы конца строки 0x13 (возврат каретки, CR) и 0x10 (перевод строки LF) преобразуются при вводе в одиночный символ перевода строки \n (при выводе выполняется обратное преобразование). Эти символы добавляются в конце каждой строки, записываемой в текстовый файл. При обнаружении в текстовом файле символа с кодом 26 (0x26), т.е. признака конца файла, чтение файла в текстовом режиме заканчивается, хотя файл может иметь продолжение.

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

#include "stdafx.h"

#include

int main()

{ FILE *f, *r; // Указатели на файлы

char ch, pr[65];

char text[]="1,2,3,4,5 i caught a fish alive, 6,7,8,9,10 i let it go again!";

f=fopen("FIL1.txt","w"); // Создание нового файла FIL1.txt

fputs(text,f); // Запись в файл строки text

fclose(f); // Закрытие файла FIL1.txt

f=fopen("FIL1.txt","r");// Открытие файла FIL1.txt для чтения

r=fopen("FIL2.txt","w"); // Создание нового файла FIL2.txt

while (!feof(f)) // Пока не конец файла FIL1.txt

{ ch=fgetc(f); // Чтение символа в ch из файла FIL1.txt

if (ch >='a'&&ch<='z') // Прочитанный символ - буква?

fputc(ch,r); // Запись в файл FIL2.txt символа из ch

}

fclose(r); // Закрытие файла FIL2.txt

rewind(f); // Возврат указателя на начало файла FIL1.txt

fgets(pr,65,f); // Чтение из файла FIL2.txt строки в переменную pr

printf("%s\n",pr); // Вывод строки pr на дисплей

r=fopen("FIL2.txt","r"); // Открытие файла FIL2.txt для чтения

while (!feof(r)) // Пока не конец файла FIL2.txt

{ ch=fgetc(r); // Чтение символа из файла FIL2.txt

putchar(ch); // Вывод символа ch на дисплей

}

printf("\n");

fclose(f); // Закрытие файлов

fclose(r);

return 0;

}

Обработка бинарных файлов

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

Составим программу создания нового файла, каждая запись которого представляет собой структуру с информацией о городе: код, название, численность жителей.
#include "stdafx.h"

#include

typedef struct town

{ int kod;

char name[10];

long c; } city;// описание структуры записи о городе

city t; // опиание переменной такой структуры

int main()

{ char c;

FILE *f;

char ch;

f=fopen("file1.dat","wb");//открытие бинарного файла для записи

printf("\n Ввод информации о городе ");

do

{

printf("\nКод: "); scanf("%d", &t.kod);

printf("\nназвание: "); scanf("%s", t.name);

printf("\nколичество жителей: "); scanf("%ld", &t.c);

fwrite(&t, sizeof(t), 1, f);//запись в файл информации о городе

printf("\n END Закончить? y/n ");

ch=getch();

}

while (ch != 'y');

fclose(f);

}

Выполнение этой программы приведет к созданию бинарного файла с информацией о городах.

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

#include "stdafx.h"

#include

typedef struct town

{ int kod;

char name[10];

long c; } city;

city t;

int main()

{

FILE *f;

f=fopen("file1.dat","rb"); //открытие бинарного файла для чтения

fread(&t, sizeof(t), 1, f); //чтение из файла одной записи в t

while (!feof(f))

{

if(t.c>1000000)

printf("\n%3d название:%10s количество жителей:%ld",

t.kod, t.name, t.c);

fread(&t, sizeof(t), 1, f);

}

fclose(f);

}

7.3 Работа с потоками в С++

Поток — это понятие, относящееся к любому переносу данных от источника к приемнику. Потоки C++ обеспечивают надежную работу как со стандартными, так и с определенными пользователем типами данных.

Для работы с файлами в С++ необходимо подключить заголовочный файл . В определены несколько классов и подключены заголовочные файлы - файловый ввод и - файловый вывод.

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

Например, необходимо создать текстовый файл и записать в него строку «Работа с файлами в С++» средствами работы с потоками. Для этого необходимо проделать следующие шаги:

создать объект класса ofstream;
cвязать объект класса с файлом, в который будет производиться запись;
записать строку в файл;
закрыть файл.

#include "stdafx.h"

#include

#include

using namespace std;

  int main(int argc, char* argv[])

{ setlocale(0,"RUS");

  ofstream fout("cppstudio.txt"); /* создаём объект класса ofstream для записи и связываем его с файлом cppstudio.txt */

  fout<< "Работа с файлами в С++";// запись строки в файл

    fout.close(); // закрываем файл

    cout<<"Файл создан"<<"\n";

    return 0;

}

Для более углубленного изучения данного подхода работы с файлами рекомендуем обратиться, например, [2],[4].

Контрольные вопросы

Описание символьных данных и строк на языке Си.
Встроенные функции языка Си, используемые для обработки строк.
Назначение функции fgets(), fputs().
Назначение функции fgetc(), fputc().
Назначение функции fscanf(), fprintf().
Обобщенная схема работы с файлами
Режимы открытие файла
Какие функции используются для чтения и записи в бинарные файлы
Назначение функции fseek().

1 ... 18 19 20 21 22 23 24 25 26

Раздел 8 Подпрограммы

8.1 Структура сложной программы

8.2 Функции

8.3 Механизмы замены параметров

8.4 Перегрузка функций в С++

8.5 Рекурсия

8.6 Технология сборки библиотеки

8.1 Структура сложной программы

Любая программа на языке высокого уровня может быть разбита на ряд логически завершенных программных единиц - подпрограмм. Такое разделение вызвано двумя причинами.

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

В языке С++ существует один вид подпрограмм, который называется функция.

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

Каждая программа на языке С++ должна иметь главную функцию (main), которая служит точкой входа в программу. Кроме главной функции в программе может быть оформлено произвольное число подпрограмм-функций. Создаваемая подпрограмма-функция должна иметь следующую структуру:
ЗАГОЛОВОК

{

Тело функции

}
Заголовок функции называется ее объявлением, а тело функции называется ее описанием. Любая подпрограмма-функция должна быть объявлена и определена.

Заголовок подпрограммы-функции должен иметь следующую структуру:
тип имя_функции ( [ список параметров])
Рассмотрим составные части заголовка.

Тип – это тип возвращаемого функцией значения. Он может быть любым(int, float, char, указатель на массив или другую функцию). Если функция не должна возвращать никакого значения, указывается тип void (пусто). Если никакой тип не указан, по умолчанию считается тип int.

Список параметров определяет величины, которые следует передать в функцию при ее вызове. Элементы списка параметров разделяются запятыми. Для каждого параметра указывается его тип и имя. Квадратные скобки около списка параметров в заголовке обозначают, что список может отсутствовать, то есть быть пустым.

Имя функции – это произвольная последовательность символов, придуманная разработчиком этой функции.

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

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

#include "stdafx.h"

ЗАГОЛОВОК

{

тело функции

}

…

main()//начало главной функции

{…

имя-функции (параметр1, параметр2,…); /*обращение к подпрограмме-функции */

…

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

Многоточие перед main обозначает, что там могут содержаться объявления и описания других функций.

Прототип функции по форме аналогичен заголовку функции, но в конце которого ставится ";". Второй вариант компоновки программы, содержащей подпрограмму-функцию, будет выглядеть так:
#include "stdafx.h"

ЗАГОЛОВОК;
main() //начало главной функции

{…

имя-функции (параметр1, параметр2,…); /*обращение к подпрограмме-функции */

…

} //конец главной функции
ЗАГОЛОВОК

{

тело функции

}

8.2 Функции

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

Общий вид описания функции

Описание функции содержит заголовок со списком формальных параметров и тело функции.

Тип Имя_функции(список формальных параметров)

{

Описание локальных переменных;

Операторы тела функции;

return результат;

}

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

типизированной.

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

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

{

Описание локальных переменных;

Операторы тела функции;

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

#include "stdafx.h"

int maximum(int a, int b) //заголовок функции maximum

{

int c; //локальная переменная

if (a>b)

c=a;

else

c=b;

return c; // возвращение результата

}
void main()

{ int x,y,z;

printf("Введите x и y:");

scanf("%d%d",&x,&y); // ввод двух чисел

z=maximum(x,y); // обращение к функции maximum

printf("max=%d\n",z);

}

Рассмотрим пример программы, использующей нетипизированную функцию. Функция Form_matrix будет заполнять целочисленную матрицу размера mxn случайными числами.

#include "stdafx.h"

#include "stdlib.h"

#define M 50

void Form_matrix(int A[][M], int m, int n) /*заголовок функции Form_matrix */

{

int i,j; //локальные переменные

for(i=0;i<m;i++)

for(j=0;j

A[i][j]=rand()%100-50;

}

void main()

{ int m1,n1,m2,n2; //переменные для задания размерности матриц

int Matr1[M][M],Matr2[M][M]; /*объявление двух матриц размера 50х50 */

printf("Введите размерность Mart1 ");

scanf("%d%d",&m1,&n1); // ввод двух чисел

Form_matrix(Matr1,m1,n1); //обращение к функции Form_matrix

printf("Введите размерность Mart2 ");

scanf("%d%d",&m2,&n2); // ввод двух чисел

Form_matrix(Matr2,m2,n2); //обращение к функции Form_matrix

…

}

Данный пример демонстрирует использование функции Form_matrix дважды в главной функции. При первом обращении к функции произойдет заполнение матрицы Mart1, а при втором обращении – Matr2, так как их имена указаны в соответствующих обращениях к функции. Функция Form_matrix может заполнить матрицу любого размера, не превышающего 50х50. (Конечно, можно было создать динамические матрицы, но это другая история, и мы говорили о ней в параграфе «Динамическая память»).

В теории о подпрограммах-функциях следует остановиться еще на трех важных вопросах:

обращение к нетипизированной и типизированной функциям;

передача параметров в функцию;

возвращение результатов.

Обращение к функции

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

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

printf("max=%d\n", maximum(x,y));

Результат выполнения функции возвращается в точку вызова функции через ее имя.
Пример программы с функцией

Вычислить значение: Z= ,

где а - заданное вещественное число.

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

где i – номер шага вычисления (умножения);

n – число шагов.

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

#include "stdafx.h"

float ST(float x, int n) // начало функции ST

{

int i;

float P; //локальные переменные i и P

P=1;

for( i=1; i<= n; i++)

P = P*x; //накопление произведения

return P;

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

void main()

{

float a,Z;

printf("Введите число а:");

scanf("%f",&a);

Z = (ST(a, 5) + ST(1/a, 5))/(2* ST(a, 7));

printf("Z=%f\n", Z);

}

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

Предыдущую программу можно скомпоновать так:

#include "stdafx.h"

float ST(float , int ); // прототип функции ST

void main()

{ float a,Z;

printf("Введите число а:");

scanf("%f",&a);

Z = (ST(a, 5) + ST(1/a, 5))/(2* ST(a, 7));

printf("Z=%f\n", Z);

}

// текст функции ST

float ST(float x, int n)

{

int i;

float P;

P=1;

for( i=1; i<= n; i++)

P = P*x;

return P;

}
Передача параметров в функцию

Механизм передачи параметров является основным способом обмена информацией между вызывающей и вызываемой функциями. Напомним, что параметры, перечисленные в заголовке функции, называются формальными, а параметры, указываемые при вызове функции – фактическими. В приведенном выше примере
Z = (ST(a, 5) + ST(1/a, 5))/(2* ST(a, 7));
при обращении к функции ST параметры a, 5, 1/a, 7 – фактические данные, с которыми будет работать функция ST в каждом своем вызове.

В заголовке функции ST
float ST(float x, int n)

x и n - это формальные параметры, которые примут в себя копии значений фактических параметров.

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

В языке С++ существует два механизма передачи параметров в функции: по значению и по адресу.

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

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

Рассмотрим два примера, иллюстрирующих механизмы передачи параметров:

Пример 1Пример 2

#include "stdafx.h" #include "stdafx.h"

void Z (int у) void Z (int *у)

{ {

y=l; *y=1;

} }

void main() void main()

{ int х; { int х;

x=0; х=0;

Z(x);//обращение к функции Z Z(&x);//обращение к функции Z

printf("x=%d", x); printf("x=%d", x);

} }
В примере 1 функция Z() содержит формальный параметр у, который передается по значению, поэтому его изменение в процедуре (у=1;) не влияет на значение фактического параметра х. После выполнения программы на экран будет выведено: х=0.

В примере 2 у функции Z() формальный параметр у – это указатель. В него передается при вызове функции Z() адрес фактического параметра x. Это означает, что функция Z() изменяет значение y в той же ячейки памяти, где находится значение фактического параметра x . На экран будет выведено:

х = 1.
Параметры-массивы в функциях

Массивы, так же как и простые переменные, можно передавать в функции в качестве параметров. Так как имя массива – это адрес, то передача массива происходит всегда по адресу.

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

#include "stdafx.h"

int Sum ( int A[], int N )//заголовок функции

{

int i, sum; //локальные переменные

sum = 0;

for ( i = 0; i < N; i ++ )

sum += A[i];

return sum/N; //возвращаемое значение

}

void main()

{

int x[5]={1,2,3,4,5},

y[3]={11,22,33};

printf("\n sr x=%d sr y=%d\n", Sum(x,5),Sum(y,3));

}

Обратите внимание, что в заголовке функции Sum размер N массива указан отдельным параметром. Нельзя объявлять массив-параметр как A[N], а только как A[]или *A.

Если в функцию передаётся двумерный массив, то описание соответствующего параметра функции должно содержать количество столбцов; количество строк - несущественно, поскольку фактически передаётся указатель. Например, так: int Х[ ][5], или Х[5][5].

Рассмотрим пример функции, перемножающей матрицы А и В; результат - матрица С. По правилам математики перемножать можно матрицы, размеры которых (mxn) и (nxk) соответственно. Результирующая матрица будет иметь размеры (mxk).

const nmax = 50;

void product(int А[][nmax], int В[][nmax],int С[][nmax], int m, int n, int k)

{
/* m - число строк в матрице А;
n - число строк в матрице В и число столбцов в матрице А;
   k - число столбцов в матрице В. */

for (int i=0; i< m; i++)
     for (int j=0; j< k; j++)

{
     С[i][j]=0;
     for (int l=0; l< n; l++)

С[i][j] + = А[i][l]*В[l][j];
}
}

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

В приведённом примере есть недостаток - здесь заранее фиксируется максимальная размерность матриц. Но использоваться может только часть памяти.

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

Результат работы функции возвращается в точку вызова с помощью оператора

return [выражение];

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

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

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

Задача 1

Даны два вектора: = {х_i}; i = и ={y_i};i= .

Вычислить значение: D = , где ; ;

тх, ту - максимальные компоненты векторов и соответственно;

sx, sy - средние значения компонент векторов и соответственно.

Решение:

#include "stdafx.h"

#include

float Mod_Otk(float *a, int n) /* типизированная функция для нахождения максимального компонента и среднего значения в любом массиве */

{

float maxi, sa, Da; //описание локальных переменных

int i;

maxi =-10000;

sa=0;

for (i =0;i

{

if (a[i]>maxi) maxi= a[i];

sa += a[i];

}

sa = sa/n;

Da= fabs(maxi - sa);

return Da;

}
void main()

{ float X[10],Y[10];

int i;

float Dx, Dy, D;

printf("Bведитe массив X:\n");

for (i =0;i<8;i++)

scanf("%f",&X[i]);

printf("Bведитe массив Y:\n");

for (i =0;i<10;i++)

scanf("%f",&Y[i]);

Dx = Mod_Otk(X, 8);//вызов функции Mod_Otk для массива X

Dy = Mod_Otk(Y,10);//вызов функции Mod_Otk для массива Y

D = Dx/Dy;

printf("D=%f\n",D);

}
Задача 2

Даны две матрицы: А = {a _i_j}₅_x₆ и В = {b_i_j}₄_x₇.

Вычислить разность: С = КА - KB, где КА и KB- количество положительных элементов в матрицах А и В соответственно.

#include "stdafx.h"

int CP(float D[7][7], int m, int n) /*типизированная функция для подсчета количества положительных элементов в любой матрице */

{ int i, j, KD;

KD=0;// инициализация счетчика

for (i=0;i

for (j=0;j

if (D[i][j]>0) KD ++; /*добавление в счетчик единицы, если элемент матрицы окажется >0 */

return KD; // возвращение результата в точку вызова

}
int main()

{

float A[7][7], B[7][7];

int i,j, C;

printf("Введите матрицу А\n");

for (i=0;i<5;i++)

for (j=0;j<6;j++)

scanf("%f",&A[i][j]);

printf("Введите матрицу B\n");

for (i=0;i<4;i++)

for (j=0;j<7;j++)

scanf("%f",&B[i][j]);
C= CP(A, 5,6)- CP(B, 4, 7); //вызовы функции СР

printf("C=%d\n", C);

return 0;

}
Задача 3

На плоскости декартовыми координатами заданы 10 точек:

{x₁,y₁},{x₂,y₂}, ...,{х₁₀,у₁₀}.

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

, где а иb -декартовы координаты точки.

Решение:

#include "stdafx.h"

#include
void PK(float a, float b, float *ro, float *fi)

/* безтиповая функция для расчета полярных координат точки */

{

*ro = sqrt(a*a + b*b);

*fi = atan(b/a);

}
int main()

{

float X[10], Y[10]; // масcивы для декартовых координат точек

float R[10], F[10]; // масcивы для полярных координат точек
int i, N;

float maxR;

printf("Введите абсциссы 10 точек\n");

for (i=0;i<10;i++) scanf("%f",&X[i]);

printf(" Введите ординаты 10 точек\n");

for (i=0;i<10;i++) scanf("%f",&Y[i]);

maxR = 0;

for (i=0;i<10;i++)

{

PK(X[i],Y[i],&R[i],&F[i]);

if (R[i]>maxR) // поиск максимального радиуса

{

maxR =R[i];

N=i; /*запоминаем номер точки, радиус которой больше, чем у предыдущих */

}

}

printf("romax=%f fimax=%f\n", R[N],F[N]);/* вывод полярных координат точки с номером N */

return 0;

}
Задача 4

Для заданных квадратных матриц: A = {a_i_j}₃_x₃и В = {b_i_j}_4х4вычислить симметричные им матрицы по правилу:

_,_x_{- матрица , симметричная матрице}_y_.

Решение:

#include "stdafx.h"
void SM(float Y[4][4], int n, float X[4][4])/*безтиповая функция вычисления симметричной матрицы X из исходной матрицы Y */

{

int i,j;

for (i=0;i

for (j=i;j

{

X[i][j]=(Y[i][j] + Y[j][i])/2;

X[j][i] =X[i][j];

}

}

void VIVOD(float Y[4][4], int n)//функция вывода матрицы

{for (i=0;i

{for (j=0;j

printf("\n");

}

}

void main()

{

float A[4][4], B[4][4], C[4][4], D[4][4];

int i, j;

printf("Введите матрицу А\n");

for (i=0;i<3;i++)

for (j=0;j<3;j++) scanf("%f",&A[i][j]);

printf("Введите матрицу B\n");

for (i=0;i<4;i++)

for (j=0;j<4;j++) scanf("%f",&B[i][j]);

SM(A, 3,C); // обращение к функции SM для матрицы A

SM(B, 4, D); //обращение к функции SM для матрицы B

printf("Симметричная матрица С\n");

VIVOD(C,3);

printf("Симметричная матрица D\n");

VIVOD(D,4);

}

8.4 Перегрузка функций в С++

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

float SUM (float a, float b);

//принимает два вещественных аргумента и возвращает результат ввиде вещественного числа
double SUM (double a, double b);

//принимает два аргумента вещественного длинного типа и возвращает результат ввиде вещественного длинного числа
complex SUM (complex a, complex b);

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

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

#include "stdafx.h"
#define complex struct compl

complex

{double x,y;};
complex SUM (complex a, complex b)

{complex c;

c.x=a.x+b.x;

c.y=a.y+b.y;

return c;

}

float SUM (float a, float b)

{float c;

c=a+b;

return c;

}

double SUM (double a, double b)

{ double c;

c=a+b;

return c;

}

int _tmain(int argc, _TCHAR* argv[])

{complex z,m,n;

float a=4.5,b=6.5;

z.x=5; z.y=6;

m.x=7;m.y=8;

n= SUM (z,m); //вызов функции SUM для комплексных параметров

printf("%lf+i%lf\n",n.x,n.y);

float d= SUM (a,b); //вызов функции SUM для вещественных параметров

printf("d=%f\n",d);

float d2= SUM (10,35); //неоднозначный вызов функции SUM

printf("d2=%f\n",d2);
return 0;

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

По типам фактических параметров компилятор определяет, какую именно функцию требуется вызвать. Этот процесс называется разрешением перегрузки (перевод английского слова resolution в смысле «уточнение»). Тип возвращаемого функцией значения в разрешении не участвует. Механизм разрешения основан на достаточно сложном наборе правил, смысл которых сводится к тому, чтобы использовать функцию с наиболее подходящими аргументами или выдать сообщение, если такой не найдется. Если точного соответствия не найдено, выполняется преобразование типов параметров по общим правилам, например char в int; int во float, float в double; и т.п. Если соответствие может быть получено более чем одним способом, вызов считается неоднозначным и выдается сообщение об ошибке. В нашем примере это продемонстрировано вызовом третьим, когда в функцию SUM передаются в качестве параметров два целых числа 10 и 35. Эти параметры могут быть преобразованы как в тип float, так и в тип double, что и вызовет возникновение ошибочной неоднозначности.

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

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

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

• Перегруженные функции могут иметь параметры по умолчанию, при этом

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

В различных вариантах перегруженных функций может быть различное количество параметров по умолчанию.

• Функции не могут быть перегружены, если описание их параметров отличается только модификатором const (например, int и const int ), или использованием ссылки (например, int и int&).

Более подробную информацию о перегруженных функциях см. в [2].

8.5 Рекурсия

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

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

Рекурсия возможна благодаря тому, что при вызове функции создаются новые экземпляры локальных переменных, которые сохраняются во внутреннем стеке машины. Стек функционирует по принципу LIFO - Last In – First Out (последний вошел – первый вышел).

Переменные помещаются в стек одна за другой и выбираются из стека в обратном порядке.

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

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

Рассмотрим пример вычисления факториала 5.

, где - это 4!

т.е 5!=4! 5

Факториал нуля равен 1. Отсюда формула вычисления N-факториала:

Реализуем вычисление факториала в виде функции:

#include "stdafx.h"

float fact(int N) //рекурсивная функция вычисления факториала числа N

Обращение функции к самой себе
{

if (N==0)

return 1;

else

return (fact(N-1)*N);

}

void main()

{ int N=15;

printf("факториал 15=%f\n",fact(N)); /* обращение к функции fact для вычисления факториала 15 */

}

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

Пример: Вычислить количество нулей в массиве А[10].

# include "stdafx.h"

const int n=10;

int kol(int i,int *A)

{ if (i==n) return 0;

else {

if(A[i]==0) return kol(i+1,A)+1;

else return kol(i+1,A);

}

}

int main()

{ int y[]={1,0,2,5,4,0,1,3,0,4,3};

int x=kol(0,y);

printf("количество нулей=%d\n",x);

}

8.6 Технология сборки библиотеки

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

Заголовочный файл (иногда головной файл, англ. header file), или подключаемый файл, в языках программирования С и C++ - это файл с расширением .h. Заголовочный файл в общем случае может содержать любые конструкции языка программирования, но на практике в него помещают объявления идентификаторов, которые должны быть объявлены более чем в одном файле вашей программы, объявления структур, прототипы функций, перечисления, макросы препроцессора. Основная цель использования заголовочных файлов — вынесение описания нестандартных типов и функций за пределы основного файла с кодом. Заголовочный файл используется путём включения его текста в использующий его файл директивой препроцессора #include. Чтобы избежать повторного включения одного и того же кода, используются директивы #ifndef, #define, #endif.

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

Пусть создаваемая нами библиотека состоит из заголовочного файла mylib.h и файла mylib.cpp.

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

Перечислим все эти функции:

maximum(). Находит и возвращает наибольшее из двух чисел.

Form_matrix(). Заполняет матрицу, адрес которой передается ей в качестве параметра, случайными числами.

ST(). Возводит любое число в степень n.

Z(). Меняет значение переданного ей параметра на случайное число.

Sum(). Вычисляет среднее арифметическое вектора, адрес и размер которого передаются в качестве параметров.

Product(). Вычисляет произведение двух матриц, адреса и размеры которых передаются в качестве параметров. Возвращает матрицу соответствующего размера.

SM(). Безтиповая функция вычисляет симметричную матрицу из исходной матрицы.

PK(). Безтиповая функция переводит декартовые координаты точки в полярные.

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

Mod_Otk(). Типизированная функция находит максимальный компонент и среднее значение в любом массиве.

fact(). Рекурсивная функция вычисляет факториал числа n.

Текст файла mylib.h:

#ifndef MYLIB_H // если MYLIB_H еще не определили, то определяем

#define MYLIB_H

const nmax = 50; // максимальная размерность матрицы

int maximum(int a, int b);//прототип функции maximum

void Form_matrix(int A[][M], int m, int n); /*прототип функции Form_matrix */

float ST(float x, int n); //прототип функции ST

void Z (int у); //прототип функции Z

void Z (int *у); //прототип функции Z

int Sum ( int A[], int N ); //прототип функции Sum

void product(int А[][nmax], int В[][nmax],int С[][nmax], int m, int n, int k); //прототип функции product

void SM(float Y[4][4], int n, float X[4][4]); /*прототип функции SM */

void PK(float a, float b, float *ro, float *fi); /*прототип функции PK */

int CP(float D[7][7], int m, int n); //прототип функции CP

float Mod_Otk(float *a, int n); //прототип функции Mod_Otk

float fact(int N); //прототип функции fact

#endif /* MYLIB_H */
Файл mylib.cpp является созданной нами библиотекой, в которой содержатся реализации всех перечисленных выше функций.

В целях экономии текст файла mylib.cpp приведем не полностью.

Текстфайлаmylib.cpp:

#include "stdafx.h"

#include "stdlib.h"

{

int Sum ( int A[], int N )//заголовок функции Sum

{

int i, sum; //локальные переменные

sum = 0;

for ( i = 0; i < N; i ++ )

sum += A[i];

return sum/N; //возвращаемое значение

}

void product(int А[][nmax], int В[][nmax],int С[][nmax], int m, int n, int k) //заголовок функции product

{
/* m - число строк в матрице А;
n - число строк в матрице В и число столбцов в матрице А;
   k - число столбцов в матрице В. */

for (int i=0; i< m; i++)
      for (int j=0; j< k; j++)

{
      С[i][j]=0;
      for (int l=0; l< n; l++)

С[i][j] + = А[i][l]*В[l][j];
}
}

float fact(int N) //рекурсивная функция вычисления факториала числа N

{

if (N==0)

return 1;

else

return (fact(N-1)*N);

…

}

Текст файла, использующего созданную библиотеку

#include "mylib.h"//подключение заголовочного файла библиотеки mylib

// главная функция выполняет основную работу программы

int main()

{

int a[nMax][nMax],b[nMax][nMax]; //объявление матриц

…

// здесь могут быть обращения к функциям библиотеки

return 0;

}
Контрольные вопросы:

Типы функции, используемые в программах на языке Си.

Структура функции, определенной пользователем.

Отличие типовой функции от безтиповой функции.

Типы параметров функции.

Глобальные и локальные идентификаторы.

Для чего используются подпрограммы?

Структура безтиповой функции, определенной пользователем.

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

Отличие параметров-значений от параметров переменных.

1 ... 18 19 20 21 22 23 24 25 26

Смотрите также файлы

бекітемін Отж проректоры.doc

Трудовые ресурсы организации.docx

Рекомендованную для Вашего устройства.pdf

Технико технологическая карта 4446 от 13. 04. 2012 Десерт Карамельный Семифредо Область применения.pdf

Анализ функционирования беспроводных сенсорных сетей.ppt

Файл: Информация и формы ее представления Информационные процессы и технологии.docx

Работа с текстовыми файлами

Обработка бинарных файлов

7.3 Работа с потоками в С++