Int fprintf(file *fp, char *format [,аргумент]…);

Эта функция выводит данные с преобразованием по формату в открытый поток fp, связанный с файлом. В случае успеха возвращает число выведенных байтов, а в случае ошибки или достижения конца файла – EOF.

Пример. Запись чисел и массива чисел в открытый файл

int a=5; float b=3.56; long c=50000;

fprintf(fp,”%d %f %ld\n”,a,b,c); //запись чисел в файл через поток fp

int arr[5]={1,2,3,4,5}; float mas[5]={1.1,2.2,3.3,4.4,5.5};

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

fprintf(fp,”%d %f\n”,arr[i],mas[i]);//запись чисел типа в поток fp

Функция форматированного ввода (чтения) из файла имеет прототип:

Int fscanf(file *fp, char *format [,указатель]…);

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

Пример. Чтение чисел и массива чисел из открытого файла

int n; float f; long l; int a[5]; float m[5];

fscanf (fp,”%d %f %ld\n”,&n,&f,&l);//чтение чисел из файла через поток

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

fscanf (fp,”%d %f\n”,&a[i],&m[i]);// чтение исел из файл через поток

Блоковый ввод данных в файл и вывод данных из файла

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

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

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

Эта функция записывает через поток fp в открытый файл n блоков, размером size байт каждый, из области памяти, определяемой указателем ptr. В случае успеха возвращает число блоков (не байтов!), а в случае ошибки или достижения конца файла – EOF.

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

struct REC {int a; float b[3];};

REC str1={1,2.2,3.3,4.4};

fwrite (&str1,sizeof(REC),1, stream);

REC str2[3]={{1,1.2,1.3,1.4},{2,2.2,2.3,2.4},{2,2.2,2.3,2.4}};

fwrite (str2,sizeof(REC),3, stream);

Функция блокового ввода (чтения) из файла имеет прототип:

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

Эта функция считывает через поток fp из открытого файла n блоков, размером size байт каждый, в область памяти, определяемой указателем ptr. В случае успеха возвращает число блоков, а в случае ошибки или достижения конца файла – EOF.

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

struct REC {int a; float b[3];};

REC str3, str4[3];

fread(&str3,sizeof(REC),1, stream);

fread (str4,sizeof(REC),3, stream);

8.7 Поняття класу. Компоненти класу. Функції класу. Доступ до членів класу. Специфікатори доступу. Конструктори та деструктори.

Визначення класу. Компоненти класу. Спеціфікатори доступу до компонентів класу. Різниця між методами класу, визначеними в класі та поза межами класу.

Основой языка С++ является понятие класса.

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

Класс в языке С++ определяется конструкцией:

ключ_класса имя_класса {список_компонентов};

где ключ_класса – одно из зарезервированных слов: class, struct, union; имя_класса – идентификатор; список_компонентов – определения и описания типизированных данных и принадлежащих классу функций.

Компонентами класса могут быть переменные, функции, классы.

Различают заголовок класса и тело класса, которое заключается в фигурные скобки.

Функции класса называют членами-функциями, компонентными функциями, методами.

Напишем простейший класс:

struct complex{

double real;

double imag;

void define(double re,double im)

{real=re; imag=im;}

void display()

{cout<<real<<"i"<<imag<<endl;}

};

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

complex x,y;

complex *py=&y;

complex z[5];

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

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

имя_объекта.имя_элемента;

имя_объекта.имя_метода();

указатель_на_объект–>имя_компонента;

Например:

x.real=2;

x.imag=3;

py–>real=7;

py–>imag=8;

x.define(1,2);

x.display(); //1+i2

py–>define(6,9);

py–>display(); //6+i9

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

тип_функции имя_класса :: имя_функции(параметры)

{тело функции;}

Например:

struct myclass{

int a;

void set(int);

int get():

};

void myclass::set(int c)

{a=c;}

int myclass::get()

{return a;}

Здесь знак :: – это оператор расширения области видимости.

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

У созданного нами класса complex есть несколько существенных недостатков. Прежде всего, общедоступность его членов-данных. Для регулирования видимости или доступа к членам класса существует спецификаторы доступа: private, protected, public, после которых ставится двоеточие.

Все члены класса (члены-данные, члены-функции) приобретают тот статус по доступу, после какого спецификатора они стоят, вплоть до следующего встретившегося спецификатора. Например:

stuct complex1{

private:

double real;

double imag;

void display();

public:

void define(double,double);

};

void complex1::display()

{cout<<real<<"+i"<<imag<<endl;}

void complex1::define(double r,double i)

{real=r;

imag=i;

display();

}

int main()

{ complex1 x;

x.define(3,5);

//x.real=8; ошибка

//x.display(); ошибка

}

Ключевое слово protected регулирует доступ при наследовании, о нем будет сказано позднее.

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

class complex{

double real, imag;

void display();

public:

void define(double,double);

void add(complex *,complex *);

};

void complex::display()

{cout<<real<<"+i"<<imag<<endl;}

void complex::define(double re,double im)

{real=re;

imag=im;

display();

}

void complex::add(complex *a,complex *b)

{real=a–>real+b–>real;

imag=a–>imag+b–>imag;

display();

}

int main()

{complex x,y,z;

x.define(3,5); //3+i5

y.define(2,4); //2+i4

z.define(&x,&y); //5+i9

return 0;

}