Слайд 2
Открытие и закрытие файла
Перед началом работы с файлом
его надо создать (открыть), а по окончании работы закрыть.
Перед началом работы с файлом надо создать указатель на структуру данных типа FILE.
Затем необходимо вызвать функцию fopen(), которая может создать новый файл для записи в него, либо открыть существующий на диске файл для записи или (и) чтения.
Слайд 3
Функции для работы с файлами
Слайд 4
Функции для работы с файлами
Слайд 5
Основы объектно-ориентированного программирования
Слайд 6
Повышение степени абстракции программы
Шаг 1 – Использование функций
Шаг
2 - Описание собственных типов данных
Шаг 3 – Объединение
в модули описаний типов данных и функций
Цель повышения уровня абстракции – представление структуры программы в виде меньшего количества более крупных блоков и минимизация связи между ними.
Слайд 7
Определения
Объектно-ориентированное программирование (ООП) — подход к программированию, при
котором основными концепциями являются понятия объектов и классов.
Объектно-ориентированное программирование,
ООП - это методика, которая концентрирует основное внимание программиста на связях между объектами, а не на деталях их реализации.
Слайд 8
Класс
В классе структуры данных и функции их обработки
объединяются.
Класс является типом данных, определяемым пользователем.
В классе задаются свойства
и поведение какого-либо предмета или процесса в виде полей данных (аналогично структуре) и функций для работы с ними.
Существенным свойством класса является то, что детали его реализации скрыты от пользователей класса за интерфейсом.
Интерфейс класса - заголовки его методов.
Слайд 9
Терминология
Объект или экземпляр класса – конкретная величина типа
данных класс.
Сообщение – запрос на выполнение действия, содержащий набор
необходимых параметров. Объекты взаимодействуют между собой, посылая и получая сообщения.
Слайд 10
Основные свойства ООП
• инкапсуляция;
• наследование;
• полиморфизм.
Слайд 11
Инкапсуляция
Инкапсуляция – объединение данных с функциями их обработки
в сочетании со скрытием ненужной для использования этих данных
информации. Инкапсуляция повышает степень абстракции программы.
Слайд 12
Инкапсуляция
Инкапсуляция представляет собой механизм, который связывает вместе код
и данные и который хранит их от внешнего воздействия
и от неправильного использования.
Именно инкапсуляция позволяет создавать объект.
Объект представляет собой логическое целое, включающее в себя данные и код для работы с этими данными. Возможно определить часть кода и данных как собственность объекта, которая недоступна извне. На этом пути объект обеспечивает существенную защиту против случайной модификации или некорректного использования таких частных членов объекта.
Во всех случаях объект представляет собой переменную, тип которой определяется пользователем.
Слайд 13
Наследование
Наследование – возможность создания иерахии классов, когда потомки
наследуют все свойства своих предков, могут их изменять и
добавлять новые. Свойства при наследовании повторно не описываются, что сокращает объем программы.
Без использования классификации каждый объект должен был бы определять все свои характеристики явным образом.
На основе классификации объект нуждается только в определении таких качеств, которые отличают его от других объектов этого класса.
Благодаря механизму наследования объект может характеризоваться в рамках классификации общего и частного.
Слайд 14
Наследование
Иерархия классов представляется в виде древовидной структуры, в
которой более общие классы располагаются ближе к корню, а
более специализированные – на ветвях и листьях.
Иногда предки называются надклассами или суперклассами, а потомки – подклассами или субклассами.
Слайд 15
Полиморфизм
Полиморфизм – возможность использовать в различных классах иерархии
одно имя для обозначения сходных по смыслу действий и
гибко выбирать требуемое действие во время выполнения программы.
«один интерфейс — множество методов»
Полиморфизм помогает уменьшить сложность программы, позволяя использовать один и тот же интерфейс для задания целого класса действий.
Слайд 17
Разница подходов к составлению программ
Процедурно-ориентированный язык:
последовательность операторов, выполняющих
обработку данных определенного типа;
тип данных задается в операторе описания
данных;
тип данных определяет:
формат представления данных в памяти компьютера;
типы операций и набор функций, которые могут использоваться с этими данными
Слайд 18
Разница подходов к составлению программ
Объектно-ориентированного подхода при составлении
программ:
Средства языка позволяют определять не только данные, но и
те операции, которые могут быть использованы с этими данными, т.е. есть эти средства определяют тип данных, определяемый пользователем – абстрактные типы данных.
Абстрактный тип данных используется для определения данных, которые называются объектами.
Объект – это совокупность данных, для которых определен набор функций. Обработка этой совокупности данных может быть выполнена только с использованием этих функций.
Слайд 19
Класс
В языке С++ для определения абстрактного типа используется
понятие класс.
Класс определяет структуру памяти будущего объекта по
данным и те функции, которые будут обрабатывать эти данные.
Программист имеет возможность вводить собственные типы данных и определять операции над ними с помощью классов.
Слайд 20
Класс
Определение класса включает в себя описание, из каких
составных частей или атрибутов он состоит и какие операции
(функции) опрелены для класса.
Данные класса называются полями (по аналогии с полями структуры), а функции класса – методами (синонимы: данные-члены и функции-члены).
Поля и методы называются элементами класса.
Слайд 21
Формат описания класса
class
{
[private: ]
<описание скрытых элементов>
public:
<описание доступных элементов>
}; // Описание заканчивается точкой с запятой
где private и public – спецификаторы доступа, управляющие видимостью элементов класса.
Слайд 22
Формат описания класса
Элементы, описанные после служебного слова private,
видимы только внутри класса, т.е. они являются закрытыми и
к ним может быть выполнено обращение только из членов-функций объекта. Этот вид доступа принят в классе по умолчанию.
Если задан режим public, то это означает, что элементы объекта являются открытыми, и к ним может быть выполнено обращение как из членов-функций (полей) объекта, так и из внешней функции, в частности, из главной функции.
Слайд 23
Формат описания класса
Интерфейс класса описывается после спецификатора public.
Действие любого спецификатора распространяется до следующего спецификатора или до
конца класса.
Можно задавать несколько секций private и public, порядок их следования значения не имеет.
Слайд 24
Поля класса
Могут иметь любой тип, кроме типа этого
же класса (но могут быть указателями или ссылками на
этот класс);
Могут быть описаны с модификатором const, при этом они инициализируются только один раз (с помощью конструктора) и не могут изменяться;
Могут быть описаны с модификатором static, но не auto, extern, register.
Инициализация полей при описании не допускается.
Слайд 25
Классы
Классы могут быть:
глобальными (объявленными вне любого блока);
локальными
(объявленными внутри блока, например, функции или другого класса).
Слайд 26
Особенности локального класса
внутри локального класса можно использовать типы,
статические (static) и внешние (extern) переменные, внешние функции и
элементы перечислений из области, в которой он описан;
запрещается использовать автоматические переменные из этой области;
локальный класс не может иметь статических элементов;
методы этого класса могут быть описаны только внутри класса;
если один класс вложен в другой класс, они не имеют каких-либо особых прав доступа к элементам друг друга и могут обращаться к ним только по общим правилам.
Слайд 27
Пример
В программе необходимо оперировать комплексными числами. Комплексные числа
состоят из вещественной и мнимой частей, и с ними
можно выполнять арифметические операции.
class Complex {
public:
int real; // вещественная часть
int imaginary; // мнимая часть
void Add(Complex x); // прибавить комплексное число
};
Слайд 28
Пример
В этом примере определен класс Complex, представляющее комплексное
число.
Оно состоит из вещественной части – целого числа
real и мнимой части, которая представлена целым числом imaginary. real и imaginary – это атрибуты класса.
Для класса Complex определена одна операция или метод – Add.
Слайд 29
Создание переменной класса
Переменная типа Complex:
Complex number;
Переменная с именем
number содержит значение типа Complex, то есть содержит объект класса Complex.
Слайд 30
Установка значений атрибутов объекта
Для существующего объекта возможна установка
значений атрибутов объекта:
number.real=1;
number. imaginary=2;
Операция “.” обозначает обращение к атрибуту объекта.
Слайд 31
Использование методов с объектами
Complex num2;
number.Add(num2);
Метод Add выполняется с
объектом.
Методы часто называются сообщениями.
Объекту number посылается сообщение
Add с аргументом num2. Объект number принимает это сообщение и складывает свое значение со значением аргумента сообщения.
Слайд 32
Примечания
Complex x1, x2, d;
// три объекта класса Complex
Complex dim [10];
// массив объектов класса Complex
Слайд 33
Описание метода класса
Void Complex::Add(Complex x)
{
this->real=this->real + x.real;
this->imaginary=this-> imaginary
+ x. imaginary;
}
Запись this говорит о том, что атрибут
принадлежит к тому объекту, который выполняет метод Add (объекту, получившему сообщение Add).
В большинстве случаев this можно опустить.
В записи определения метода какого-либо класса упоминание атрибута класса без всякой дополнительной информации означает, что речь идет об атрибуте текущего объекта.
Слайд 34
#include
#include
using namespace std;
class Complex {
public:
int real;
// вещественная часть
int imaginary; // мнимая часть
void Add(Complex x); // прибавить комплексное число
};
void Complex::Add(Complex x)
{
real=real+x.real;
imaginary=imaginary+x.imaginary;
}
int main()
{
setlocale(LC_ALL, "rus");
Complex number;
number.real=1;
number.imaginary=2;
cout<<"Объект number, вещественная часть: "< Complex num2;
num2.real=2;
num2.imaginary=3;
cout<<"\nОбъект num2, вещественная часть: "< number.Add(num2);
cout<<"\nОбъект number после выполения метода Add, вещественная часть: "< return 0;
}
Слайд 35
Пример 2
Задана структура класса Q
члены данные: массив целых чисел; n - переменная, определяющая текущий размер массива;
члены-функции (методы):
функция ввода данных в объект;
функция вывода;
функция вычисления максимального элемента массива объекта;
Программа реализует следующий алгоритм:
создание объекта заданного класса;
ввод данных в объект;
вывод данных объекта;
вычисление максимальной величины массива объекта
печать результата.
Слайд 36
#include
#include
class Q
//Объявление клаcса Q
//Объявление член-данных
private:
int mas[100]; //массив целых чисел;
int kol;
//текущий размер массива
//Объявление член-функций (методов)
public:
void Enter(); /*Объявление член-функции ввода данных */
void output(); /*Объявление член-функции вывода данных */
int funk(); /*объявление член-функции нахождения
максимального элемента массива */
}; //конец объявления класс Q
Слайд 37
int main()
{
setlocale(LC_ALL, "rus");
int m;
Q obj;
//Создание
объекта
obj.Enter(); //Ввод данных
obj.output(); //Вывод данных
m=obj.funk(); //Нахождение max
cout <<"\n\n Результат:"
<<"\Максимальный элемент равен: " < return 0;
}
Слайд 38
void Q::Enter()
//отложенное определение функции ввода данных
{
cout
массива kol=";
cin >>kol;
cout
<<«Введите mas["<<(i+1)<<"]=";
cin >>mas[i];
cout < }
}
void Q::output() /* отложенное определение функции вывода массива объекта */
{
cout <<"\n Массив: ;
for(int i=0; i cout <}
int Q::funk() /* отложенное определение функции
нахождения max*/
{
int max=mas[0];
for(int i=1; i if(max return (max); /*возврат в вызвавшую функцию значения max */
}
Слайд 40
Пример 3
Программа реализует следующий алгоритм:
создание объекта c выделенной памятью для массива слов ;
ввод массива слов в объект;
вывод данных объекта;
выполнение функции вычисления слова с max длиной;
распечатка в основной программе найденного слова и его длины с использованием возвращенных параметров - слова и его длины.
Слайд 41
Задана структура класса Q:
члены данные:
массив слов (максимальный размер массива 100);
максимальная длина слова len=11;
n - количество элементов массива (текущий размер);
Члены функции (методы):
функция ввода данных объекта;
функция вывода данных объекта;
функция определения слова с максимальной длиной (передача этого слова в вызывающую функцию и его порядкового номера).
Слайд 42
#include
#include
#include
class Q
//Объявление класcа Q
{
int kol;
//текущий размер массива слов
char mas[100][11]; //массив слов
public: //Объявление член-функций (методов)
void Enter(); //Объявление член-функции ввода данных
void Output(); //Объявление член-функции вывода данных
int Funk(char *); /*объявление член-функции нахождения слова максимальной длины и длины этого слова*/
}; //конец объявления класса Q
Слайд 43
int main()
{
setlocale(LC_ALL, "rus");
int max=NULL;
// результат- максимальная длина и слово максимальной длины
char str[255]={NULL};
Q
obj; //Объявление объекта
obj.Enter(); //Ввод данных
obj.Output(); //Вывод данных
max=obj.Funk(str); /*Вычисление слова с максимальной длиной и запись слова в строку str и длины в переменную max */
cout <<"\n Результат:"\nСамое длинное слово:"< return 0;
}
Слайд 44
void Q::Enter() /* отложенное определение член-функции ввода данных
*/
{
cout kol;
cout
массива слов:”;
cin.get();
for(int i=0; i {
cout <<"\nВведите mas["<<(i+1)<<"] :”;
cin.getline(mas[i],11);
if(!cin) cin.clear();
}
}
Слайд 45
void Q::Output() /* отложенное
определение член-функция
вывода данных */
{
cout
массива слов:"
<<"\n-----------------------";
for(int i=0; i cout <<"\n["<<(i+1)<<"]. ->"<}
/* отложенное определение член-функция определения слова с max длиной */
int Q::Funk(char *max_word) // возвращает слово и длину
{
int max_len=strlen(mas[0]); // вычисление длины первого слова
int temp_len=NULL; // рабочая переменная для текущей длины
strcpy(max_word,mas[0]); /* фиксирование первого слова в результате */
for(int i=1; i {
temp_len=strlen(mas[i]);
if(temp_len>max_len)
{
max_len=temp_len; // фиксирование максимальной длины
strcpy(max_word,mas[i]); /* фиксирование слова с макси-
мальной длиной */
}
}
return(max_len); /*Возврат длины самого длинного слова
в вызвавшую функцию */
}
Слайд 47
Переопределение операций
В языке С++ допустимо, что класс будет
практически неотличим от предопределенных встроенных типов при использовании в
выражениях.
Для класса можно определить операции сложения, умножения и т.д. пользуясь стандартной записью таких операций, т.е. x + y.
В языке С++ считается, что подобная запись – это также вызов метода с именем operator+ того класса, к которому принадлежит переменная x.
Слайд 48
Переопределение операций
// определение класса комплексных чисел
class Complex
{
public:
int
real; // вещественная часть
int imaginary; // мнимая часть
// прибавить комплексное число
Complex operator+ (const Complex x) const;
};
Слайд 49
Complex operator+ (const Complex x) const;
Вместо метода
Add появился метод operator+.
Этот метод возвращает значение типа
Complex (операция сложения в результате дает новое значение того же типа, что и типы операндов).
Перед аргументом метода появилось ключевое слово const, означающее, что при выполнении данного метода аргумент изменяться не будет.
Второе ключевое слово const означает, что объект, выполняющий метод, не будет изменен.
При выполнении операции сложения x + y над двумя величинами x и y сами эти величины не изменяются.
Слайд 50
Определение операции сложения
Complex:: operator+ (const Complex x) const
{
Complex
result;
result.real = real + x.real;
result. imaginary = imaginary +
x. imaginary;
return result;
}
Слайд 51
Переопределение операций
В языке С++ допускается определение в одном
классе нескольких методов с одним и тем же именем,
но разными типами и количеством аргументов.
Определение методов или атрибутов с одинаковыми именами в разных классах не вызывает проблем, поскольку пространства имен разных классов не пересекаются.
Слайд 52
Переопределение операций
// определение класса комплексных чисел
class Complex
{
public:
int
real; // вещественная часть
int imaginary; // мнимая часть
// прибавить комплексное число
Complex operator+ (const Complex x) const;
// прибавить целое число
Complex operator+ (long x) const;
};
Слайд 53
Пример
Complex c1;
Complex c2;
long x;
c1 + c2;
c2 + x;
Слайд 54
Полный пример
#include
#include
using namespace std;
class Complex {
public:
int
real; // вещественная часть
int imaginary; // мнимая часть
// прибавить комплексное число
Complex operator+(const Complex x)const;
// прибавить целое число
Complex operator+(long x)const;
};
Complex Complex::operator+(const Complex x) const
{
Complex result;
result.real = real + x.real;
result. imaginary = imaginary + x. imaginary;
return result;
}
Complex Complex:: operator+ (long x) const
{
Complex result;
result.real = real + x;
result. imaginary = imaginary + x;
return result;
}
