ООП. Абстракция, полиморфизм, наследование, инкапсуляция
Объе́ктно-ориенти́рованное, или объектное, программи́рование (в дальнейшем ООП) —парадигма программирования, в которой основными концепциями являются понятия объектов и классов.
Инкапсуляция – это свойство системы, позволяющее объединить данные и методы, работающие с ними, в классе и скрыть детали
реализации от пользователя.
Например:
class A
{
public:
int a, b; //данные открытого интерфейса
int ReturnSomething(); //метод открытого интерфейса
private:
int Aa, Ab; //скрытые данные
void DoSomething(); //скрытый метод
};
PS. Надо указать также то, что при инкапсуляции, пользователь может взаимодействовать с открытыми(public) методами и данными, а с закрытыми(private) только через открытые методы.
Наследование – это свойство системы, позволяющее описать новый класс на основе уже существующего с частично или полностью заимствующейся функциональностью. Класс, от которого производится наследование, называется базовым или родительским. Новый класс – потомком, наследником или производным классом.
Например:
class A{ //базовый класс}; class B: public A{ //public наследование (public -> public, protected -> protected)}; class C: protected A{ //protected наследование (public, protected -> protected)}; class Z: private A{ //private наследование (public, protected -> private)};
Полиморфизм – это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта. (переопределение, перегрузка и тд).
Абстрагирование – это способ выделить набор значимых характеристик объекта, исключая из рассмотрения незначимые. Соответственно,
абстракция – это набор всех таких характеристик.
Например:
Абстрактный класс – это базовый класс, объекты которого никогда не будут реализованы. Такой класс может существовать с единственной целью – быть родительским классом для классов, в которых объекты будут определены.
Class negative
{
Private:
int x;
Public:
Virtual void show() = 0;
};
PS В C++ абстрактные методы или чисто виртуальные функции получаются добавлением так называемого чистого описателя (=0) в определение метода. Абстрактные классы являются просто классами с одним или более абстрактным методом (или наследующие их). Вы не можете создать объект абстрактного класса.
2. Разработка класса в ООП: определение и реализация класса. Члены класса. Уровни видимости. inline-функции. Статические члены класса.
Класс – это способ описания сущности, определяющий состояние и поведение, зависящее от этого состояния, а также правила для взаимодействия с данной сущностью (контракт).
С точки зрения программирования класс можно рассматривать как набор данных (полей, атрибутов, членов класса) и функций для работы с ними (методов).
С точки зрения структуры программы, класс является сложным типом данных.
Вот C++ синтаксис определения простого класса:
class Date {
private: // скрытые данные(доступны внутри класса)
int dd; //объект(поле) класса
int mm;
int yy;
public: //открытые данные
void Init (int d, int m, int y); // метод класса
int Day ();
int Month ();
int Year ();
};
А вот определение одного из методов:
void Date::Init (int d, int m, int y)
{
dd = d;
mm = m;
yy = y;
}
Реализация:
Int main()
{
Date asd;
asd.init(1, 2, 3);
…
return 0;
}
Подставляемые (inline) функции
Подставляемые функции не вызываются как обычные функции языка C++. В машинный код программы вставляется код, соответствующий этой функции. Это как бы параметризированная макроподстановка, но уже на процессе компиляции.
Чаще всего, инлайн-функции определяются внутри класса(так они по принципу инлайн)
ОО языки обычно разрешают заводить методы и данные, относящиеся к классу целиком, а не к отдельным объектам. Метод класса обычно может быть вызван как для объекта класса, так и применён к классу в целом. Данные класса не повторяются для каждого объекта, а разделяются между всеми объектами данного типа. В C++ методы и данные класса отмечаются ключевым словом static. Данные класса должны быть проинициализированы специальным объявлением, ещё одной уступкой отсутствию модулей.
Конструкторы и деструктор: назначение и типы конструкторов; определение и реализация конструкторов; параметры по умолчанию. Использование конструкторов при различных способах создания экземпляров класса. Назначение и использование деструктора. Определение и реализация деструктора.
конструктор класса — специальный блок инструкций, вызываемый при создании объекта. Их задача — инициализировать члены объекта и определить инвариант класса, сообщив в случае некорректности инварианта. Корректно написанный конструктор оставит объект в «правильном» состоянии.
§ конструктор по умолчанию — конструктор, не принимающий аргументов;
§ конструктор копирования — конструктор, принимающий в качестве аргумента объект того же класса (или ссылку из него);
§ конструктор преобразования — конструктор, принимающий один аргумент (эти конструкторы могут вызываться автоматически для преобразования значений других типов в объекты данного класса).
class Complex
{
public:
// Конструктор по умолчанию
Complex():re(0), im(0) {}
// конструктором преобразования
Complex(double i_re = 0, double i_im = 0): re(i_re), im(i_im) {}
// Конструктор копирования
Complex(const Complex &obj)
{
re = obj.re;
im = obj.im;
}
private:
double re, im;
};
Деструктор играет роль противоположную конструктору и обычно вызывается при уничтожении объекта. Если конструктор нужен большинству классов, то только некоторые из них нуждаются в деструкторе. Деструктор в основном используется для освобождения ресурсов, зарезервированных конструктором (или другими методами во время жизни объекта). Эти ресурсы включают память, файлы, базы данных, ресурсы ОС и т. д.
C++: деструкторы вызываются автоматически, когда объект выходит из области определения или когда вы удаляете объект, заведенный динамически. У каждого класса есть только один деструктор, который объявляется как ~Class(), где Class - имя класса. Если объект создан в куче, то он не может быть автоматически удален и если не объявить деструктор явно в программе, то происходит утечка памяти
1.
Методы класса: классификация методов, доступ к членам класса, неявный параметр this. Определение и реализация методов. Использование методов для экземпляров класса.
Методы класса
Классы C++ позволяют вашим программам группировать данные объекта и функции объекта (методы), которые оперируют с этими данными, в одной переменной. У вас есть две возможности определения методов объекта. Первая состоит в том, что вы можете включить весь код функции внутрь определения класса. Несмотря на то что включение кода метода в определение класса может представляться удобным, однако, когда классы становятся сложнее и включают несколько методов, операторы функций могут вносить беспорядок в определение классов. Таким образом, многие программы определяют операторы функции вне класса. В определение класса программа должна включать прототип функции, который указывает имя функции, тип возвращаемого значения и типы параметров. Для определения функции вне определения класса ваша программа должна предварять определение функции именем класса и оператором глобального разрешения, как показано ниже:
return_type class_name::function_name(parameters)
Методы класса вызываются с помощью оператора точка.
Например:
class employee
{
public:
char name [64]; // Некоторые элементы класса
long employee_id;
float salary;
void show_employee(void);
};
void employee::show_employee(void) // Метод класса. Определенный
{
cout << "Имя: " << name << endl;
cout << "Номер служащего: " << employee_id << endl;
cout << "Оклад: " << salary << endl;
};
void main(void)
{
employee worker, boss; // Создание элемента класса
strcpy(worker.name, "John Doe");
worker.employee_id = 12345;
worker.salary = 25000;
strcpy(boss.name, "Happy Jamsa");
boss.employee_id = 101;
boss.salary = 101101.00;
worker.show_employee(); // Вызов метода класса, через точку (использование для экземпляра класса)
boss.show_employee();
}
Ключевое слово this обозначает объявленный неявно указатель на себя.Другими словами, при реализации функций-членов класса, мы работаем с данными так, как будто они передаются через указатель this. Особенностью this является то, что он предоставляет встроенный не требующий объявления указатель. Другими словами, например, это то же самое, как если бы в классе Test неявно объявлялся закрытый член Test* const this. Заметим, что указатель this изменить нельзя. Обычно указатель this используется неявно, но в некоторых ситуациях желательно его явное использование, причем, использование this не отличается от использования любого другого указателя.
class Test
{
public:
Test(char b) //конструктор
{
c1=b;
c2=c1+1;
}
Test Increment() //функция увеличения
{
c1++;
c2++;
return (*this); //вернуть объект
}
Test* Where_Am_I() //функция возвращает адрес памяти где расположен наш объект
{
return this; //вернуть указатель на себя
}
private:
char c1,c2;
};
void main()
{
Test a('A'); //создадим экземпляр класса Test
Cout << "is at" << a.Where_Am_I() << endl ; //узнаем где мы (т.е. выведем адреса памяти, где расположен наш объект)
a.Increment(); //вызываем функцию-член Increment()
}
Перегрузка функций: правила перегрузки, выбор функции. Использование перегруженных функций.
Перегрузка функций позволяет вашим программам определять несколько функций с одним и тем же именем и типом возвращаемого значения.
Cуществует два основных способа перегрузки операторов: глобальные функции, дружественные для класса, или подставляемые функции самого класса.
int add_values(int a,int b) //Перегруженная функция (2 параметра)
{
return(a + b);
}
int add_values (int a, int b, int c) // Перегруженная функция (3 параметра)
{
return(a + b + c);
}
void main(void)
{
cout << "200 + 801 = " << add_values(200, 801) << endl; // Использование функции с 2 параметрами
cout << "100 + 201 + 700 = " << add_values(100, 201, 700) << endl; // Использование функции с 3 параметрами
}
Одним из наиболее общих случаев использования перегрузки является применение функции для получения определенного результата, исходя из различных параметров.
Перегрузка операторов: правила перегрузки, перегрузка бинарных и унарных операторов. Использование перегруженных операторов. Понятие объектов функций (функторов).
Синтаксис перегрузки
class Integer
{
private:
int value;
public:
Integer(int i): value(i)
{}
const Integer operator+(const Integer& rv) const { //перегрузка унарного оператора
return (value + rv.value);
}
};