Основы ООП

взаимосвязанных абстрактных объектов и их реализаций
Основными концепциями ООП являются Классы

данных, объединяющего данные и методы их обработки
Класс – тип, описывающий

методы)
};

информацию об объекте, формируют его состояние, характеристики и т.п.
Изменение состояния

пробега
Цвет кузова

манипуляцию данными объекта
Метод объекта – программный код, выполненный в виде

кузов
Изменяет цвет кузова
Заправить топливо
Увеличивает количество топлива

как к переменной объекта
В некоторых объектно-ориентированных языках программирования (например, в

окружности
Методы
Переместить в заданном направлении
Отмасштабировать
Повернуть вокруг заданной точки

double dy);
void Scale(double sx, double sy);
void Rotate(Point center, double angle);
private:
Point

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

методов
Согласно данному принципу, класс должен рассматриваться как черный ящик
Внешний пользователь

для реализации стека целых чисел
};
Пример. Стек целых чисел

(базового) класса
Класс-потомок может добавить свои собственные свойства и методы, пользоваться

Attack();
private:
int m_ammo;
};

класса-предка, сохраняя его интерфейс
Полиморфизм позволяет обрабатывать объекты классов-потомков как однотипные

width * height;
}
private:
double width, height;
};

class Circle : public Shape
{
public:
virtual double GetArea()
{
return

слово class
Синтаксис
class идентификатор { // объявление данных и методов };
Реализация методов

Date::Print()const
{
std::cout

в заголовочных файлах .h, а их реализации – в файлах

Date::Print()const
{
// ...
}
...
main.cpp


#include “date.h”

int main()
{
Date date1;
...
return 0;
}

методам класса извне может быть ограничен
Рекомендуется запрещать доступ к данным

к ним возможен из любой части кода
необходимо помещать в public-раздел

к ним разрешен только из методов данного класса
Рекомендуется все данные

к ним разрешен изнутри методов данного класса и всех его

Нельзя потратить отрицательное количество денег или больше,
// чем имеется в

денег - только деньги на сладости
return m_moneyForSweets;
}
protected:
virtual void SpendMoneyImpl(int amount)
{
//

формируются из нескольких "заначек"
return m_moneyForBeer + m_moneyForFood + m_moneyForGirls;
}
protected:
virtual void

сколько есть у студента + деньги на защиту диссертации
return CStudent::GetMoneyAmount()

можно использовать их имена
В метод класса неявно передается указатель на

*m_pNext;
ListItem *m_pPrevious;
int m_data;
};

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

константа, либо доступен по константной ссылке или указателю на const,

0;
}
private:
int *m_pData;
int m_numberOfItems;
};

void f(IntArray const& array)
{
int i = array.GetSize(); // можно
array.ClearElements(); //

константных методов класса в С++ объявляются с ключевым словом mutable
Пользоваться

требует длительных вычислений)
m_areaInitialized = true;
…
}
return m_area;
}
void ModifyShape(...)
{
m_areaInitialized = false;
// ...
}
private:
mutable

существует специальная функция – конструктор
Конструктор имеет то же имя, что

= GetCurrentYear();
}
Date(int day, int month, int year)
{
m_day = day;
m_month =

данных в таком конструкторе инициализируются значениями по умолчанию
Создавать такой конструктор

классы
Их инициализация осуществляется ДО выполнения тела конструктора
Для их инициализации вызываются

его тела
Использование списков инициализации – единственное решение в случае, когда

на документом
};

class CEditor
{
public:
CEditor(CDocument & document)
:m_document(document)
{
}
void Undo();
void Redo();
void ReplaceText(
size_t offset, size_t

int main(int argc, char * argv[])
{
CDocument document;
document.Open("fileName.doc");

CEditor editor(document);

// Вызываем операции редактора документа
// …

document.Save("fileName1.doc");

return 0;
}

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

символ ~ (тильда)
Данный метод вызывается автоматически при уничтожении экземпляра класса:
Выход

жизненный цикл объекта
Освобождение выделенных объектом ресурсов
Что-нибудь еще

NULL;
}
void Close()
{
if (m_pFile)
{
fclose(m_pFile);m_pFile = NULL;
}
}
...
private:
FILE *m_pFile;
};
int main(int argc, char *

вызов деструкторов членов-данных класса
Порядок вызова деструкторов обратен порядку объявления
Если класс

m_name

"Constructing car "

Kalina");

return 0;
}
Constructing wheel Front left
Constructing wheel Front right
Constructing wheel Rear

Конструирование полей базового класса Car

Выполнение тела конструктора класса Car

Конструирование полей класса SuperCar

Тело конструктора класса SuperCar

Тело деструктора класса SuperCar

Деструкторы полей полей класса SuperCar

Тело деструктора класса Car

Разрушение полей класса SuperCar

Output:

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

класса CDataBase деструкторы содержащихся в нем объектов освободят занимаемую память

* m_bufferArray;
std::string m_databaseName;
MyFile m_databaseFile;
};
Автоматически сгенерированный деструктор не выполнит удаление массива

использующийся для создания копии объекта
Явное создание копии объекта программистом
Неявное создание

компилятор сгенерирует его во время компиляции
Автоматически сгенерированный конструктор копирования осуществляет

foo\n";
}
private:
int m_moo;
};
class Bar
{
public:
void Do()
{
std::cout

OUTPUT:
Call f()
Creating copy of foo
f()
Do
Call g()
g()
Creating copy of foo
Do

копирования не подходит
Пример – класс, реализующий массив
Стандартный конструктор копирования просто

!= 0)
{
memcpy(m_pData, arr.m_pData, sizeof(int) * m_size);
}
}

private:
int * m_pData;
int m_size;
};

смысла и должна быть запрещена
Класс, инкапсулирующий сетевое соединение
Класс, инкапсулирующий работу

каждого объекта создается своя собственная копия членов данных
Методы класса работают

к статическим данным класса
Статические методы могут вызывать только статические методы
Либо

const Foo::m_className = "Foo";

main.cpp:
#include "foo.h"
int main(int argc, char *argv[])
{
std::cout

метод для создания класса в куче
Паттерн «одиночка» (singleton)
Объект с глобальным

= new Singleton();
}
return *m_pInstance;
}
void SomeMethod(){}
private:
Singleton(){}
static Singleton *m_pInstance;
};
// singleton.cpp
Singleton* Singleton::m_pInstance =

Open(std::string const& fileName)
{
boost::shared_ptr pFile(new CFile());
if (!pFile->OpenFile(fileName))
{
pFile.reset();
}
return pFile;
}
static boost::shared_ptr Create(std::string const&

объявление одного класса (или другого типа данных) внутри объявления другого
Это

класса можем обращаться по имени
Internal internal;
internal.Foo();
}
};

int main(int argc, char* argv[])
{
External::Internal

класс Impl хранит все
// приватные данные и методы
// класса CComplexClass
class

// ComplexClass.cpp
class CComplexClass::Impl
{
public:
void Foo()
{
//…
}
private:
// …
};

CComplexClass::CComplexClass()
:m_pImpl(new Impl())
{
}

CComplexClass::~CComplexClass()
{
delete m_pImpl;
}

void CComplexClass::Foo()
{
m_pImpl->Foo();
}

Данный подход позволяет в языке C++ сократить количество зависимостей времени компиляции от модификации приватной части класса, т.к. она фактически вынесена из заголовочного файла в .CPP файл