Способы создания и разрушения объектов

Способы создания и разрушения объектов

Место имён.

Классы позволяют создавать огромное количество объектов, любой из которых имеет собственные значения атрибутов. Нет потребности вводить огромное количество переменных, т.к объекты получают в свое распоряжение личные так именуемые места имен. Место имен определенного объекта формируется на базе класса, от которого он был сотворен, также от всех родительских классов данного Способы создания и разрушения объектов класса. Объект можно представить как некоторую упаковку данных.

Место имен namespace это новый элемент языка и для работы с STL мы должны принять его во внимание. Этот элемент сотворен для программ сделанных из многих файлов, в каких есть опасность конфликта имен.

Объявляется место имен командой namespace:

C++ Спецификацияnamespace [идентификатор Способы создания и разрушения объектов]{ описание для этой рабочей области }

Для использования рабочей области применяется команда using namespace

#include "stdafx.h"#include "iostream.h" namespace spaceA{ int MyVal=10;} namespace spaceB{ int MyVal=20;} namespace spaceC{ int MyVal=30;} void Test(){ using namespace spaceB; cout << MyVal << " " << "spaceB" << endl;} void main(){ using namespace spaceA; cout << MyVal << " " << "spaceA" << endl; Test(); cout << spaceC::MyVal Способы создания и разрушения объектов << " " << "spaceC" << endl;}


Неувязка множественного наследования

Класс может наследовать функциональность от нескольких классов. Это именуется множественным наследованием. Множественное наследование создаёт известную делему (в C++), когда класс наследуется от нескольких классов-посредников, которые в свою очередь наследуются от 1-го класса (так именуемая «Проблема ромба»): если способ общего предка был переопределён в Способы создания и разрушения объектов посредниках, непонятно, какую реализацию способа должен наследовать общий потомок. Решается эта неувязка оковём отказа от множественного наследования для классов и разрешением множественного наследования для стопроцентно абстрактных классов (другими словами интерфейсов) (C#, Delphi, Java), или через виртуальное наследование (C++).
37. Статические члены класса

Члены класса могут быть объявлены с внедрением Способы создания и разрушения объектов модификатора класса памяти static

. Такие члены данных делятся всеми экземплярами данного класса и хранятся в одном месте. Нестатические члены данных создаются для каждой переменной-объекта класса.

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

Потому что статический член класса не находится в зависимости от определенного экземпляра, то воззвание к Способы создания и разрушения объектов нему смотрится последующим образом:

class_name::variable

где class_name – это имя класса, а variable значит имя члена класса.

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

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

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

//+------------------------------------------------------------------+ //| Класс "Анализатор текстов" | //+------------------------------------------------------------------+ class СParser { public: static int s_words; static int s_symbols; //--- конструктор и деструктор Parser(void); ~Parser(void){}; }; ... //--- инициализация статических членов класса Parser на глобальном уровне int CParser::s_words=0; int CParser::s_symbols=0;

Методы сотворения Способы создания и разрушения объектов и разрушения объектов

Особенной разновидностью способов являются конструкторы и деструкторы. Создание объекта включает выделение памяти под экземпляр и инициализацию его полей, а разрушение - чистку полей и освобождение памяти. Деяния по инициализации и чистке полей специфичны для каждого определенного класса объектов. По этой причине язык Delphi позволяет переопределить стандартный конструктор Create Способы создания и разрушения объектов и стандартный деструктор Destroy для выполнения всех нужных действий. Можно даже найти несколько конструкторов и деструкторов (имена им назначает сам программер), чтоб обеспечить разные процедуры сотворения и разрушения объектов.
Объявление конструкторов и деструкторов похоже на объявление обыденных способов с той только различием, что заместо зарезервированных слов function и procedure употребляются слова Способы создания и разрушения объектов constructor и destructor. Пример:
type TPeople = class
Name: string;
Family: string;
procedure GetName;
procedure GetFamily;
construcor Create;
destrucot Destroy;
end;
Вероятная реализация:

procedure TPeople.Create;
begin
TPeople.Name := ' ';
TPeople.Family := ' ';
end;
procedure TPeople.Destroy;
begin
//Пока ничего не делаем
end;
Если объект содержит интегрированные объекты либо другие динамические данные, то конструктор Способы создания и разрушения объектов - это как раз то место, где их необходимо создавать. Конструктор применяется к классу либо к объекту. Конструктор создаёт новый объект исключительно в том случае, если перед его именованием обозначено имя класса. Если указать имя уже имеющегося объекта, он поведёт себя по-другому: не создаст новый объект, а только Способы создания и разрушения объектов выполнит код, находящийся в теле конструктора. Если он применяется к классу,

People := TPeople.Create;

то производится последующая последовательность действий:
1. В динамической памяти выделяется место для нового объекта.
2. Выделенная память заполняется нулями. В итоге все числовые поля и поля порядкового типа получают нулевые значения, строковые поля становятся пустыми, а поля, содержащие указатели и Способы создания и разрушения объектов объекты получают значение nil.
3. Потом производятся данные программером деяния конструктора.
4. Ссылка на сделанный объект ворачивается в качестве значения конструктора. Тип возвращаемого значения совпадает с типом класса, использованного при вызове (в нашем примере это тип TPeople).

Таким макаром, хотя на 1-ый взор синтаксис конструктора идентичен с вызовом процедуры Способы создания и разрушения объектов (не определено возвращаемое значение), но по сути конструктор - это функция, возвращающая сделанный и инициализированный объект. Если конструктор применяется к объекту,

People.Create;

то конструктор производится как обыденный способ. Другими словами, новый объект не создаётся, а происходит повторная инициализация полей имеющегося объекта. В данном случае конструктор не возвращает никакого значения Способы создания и разрушения объектов. Далековато не все объекты корректно себя ведут при повторной инициализации, так как программеры изредка закладывают такую возможность в свои классы. Потому на практике повторная инициализация применяется очень изредка.

Деструктор уничтожает объект к которому применяется:

People.Destroy;

В итоге производятся:
1. Данный программером код окончания.
2. Освобождается занимаемая объектом динамическая память.
В теле деструктора Способы создания и разрушения объектов обычно должны уничтожаться интегрированные объекты и динамические данные, обычно, сделанные конструктором. Как и обыденные способы, деструктор может иметь характеристики, но эта возможность употребляется очень изредка.
23.Иерархия классов

Иерархию классов в ООП можно выстроить по-разному. Практически иерархия классов является классификатором объектов. В этом случае при построении системы Способы создания и разрушения объектов классов разработчик пробует принять во внимание последующие суждения «Столь ли существенна разница меж рублевыми и денежными вкладами, что их следует поделить на разные классы?», «Разные виды Депозитов — это различные свойства 1-го и такого же класса либо же различные классы?» и т.п.

Как видно из рисунка, представленного выше, разница меж рублевым и Способы создания и разрушения объектов денежным счетом так существенна, что они выделены в различные классы. Различные виды Депозитов также представлены различными классами. Если б решили, что валютная единица, в какой выражается сумма на счете, — только дополнительны атрибут счета, и различные типы депозитов различаются дополнительной чертой класса «Депозит», то иерархия классов преобразовалась бы к виду Способы создания и разрушения объектов, изображенному на рисунке:


25,26,27.

Инкапсуляция. Виды доступа к способам и атрибутам, видимость. Примеры (эл. конспект лекций);

Полиморфизм. Определение, внедрение полиморфизма в ООП. Примеры (эл. конспект лекций);

Наследование. Определение, внедрение наследования в ООП. Примеры (эл. конспект лекций);

Объектно-ориентированное подход рассматривает программки, как совокупы гибко связанных меж собой объектов, любой Способы создания и разрушения объектов из которых отвечает за определенные задачки. Каждый объект является экземпляром некого класса. Все экземпляры 1-го класса будут вести себя схожим образом (другими словами вызывать те же способы) в ответ на схожие запросы. Объектно-ориентированное приложение также характеризуется поддержкой 3-х общих параметров: инкапсуляции, наследования и полиморфизма.

Инкапсуляция значит Способы создания и разрушения объектов, что данные объекта недосягаемы его клиентам конкретно. Заместо этого они инкапсулируются – скрываются от прямого доступа. Единственный метод доступа к данным объекта – его способы. В совокупы они составляют предопределенный интерфейс с наружным миром. Инкапсуляция защищает данные объекта от ненужного доступа. Объект сам управляет доступом к своим данным.

Понятие инкапсуляция значит, что функции элементы Способы создания и разрушения объектов и структуры данных, определяющие некие характеристики данного класса, рассматриваются в качестве одного целого. Это предполагает "защиту" данных в границах класса таким макаром, что только элементы класса получают к ним доступ. Другими словами, для того чтоб получить значение 1-го из частей данных класса, необходимо вызвать функцию элемент этого класса Способы создания и разрушения объектов, который возвращает нужное значение. Для присвоения элементу значения, вызывается соответственная функция элемент данного класса. Вообщем, в объектном программировании считается неплохим тоном закрывать все данные и функции элементы описываемого класса для доступа "снаружи".

2-ой определяющей чертой объектно-ориентированных технологий является полиморфизм. Полиморфизм, просто говоря, значит, что клиент может рассматривать Способы создания и разрушения объектов различные объекты как однообразные и любой из объектов будет вести себя подходящим образом. Возможность рассматривать различные вещи единообразно – сущность полиморфизма. Обычной пример: сути классов "стол", "стул" и "шкаф" - это представители различных классов, но на определенном уровне абстракции они единообразны и все являются экземплярами класса "мебель".

Последняя определяющая черта обычных объектно-ориентированных Способы создания и разрушения объектов технологий – наследование. Мысль ординарна: имея один объект, можно сделать новый, автоматом поддерживающий все либо некие «способности» старенького. Необходимо подчеркнуть различия наследования реализации и наследование интерфейса. В первом случае объект наследует от собственного родителя код. В противоположенность этому наследование интерфейса в реальности значит повторное внедрение спецификации – определений способов, поддерживаемых Способы создания и разрушения объектов объектом. Наследование интерфейса упрощает к тому же реализацию полиморфизма.

Время от времени в подклассе бывает нужно переопределить операцию, определенную в одном из его суперклассов. Для этого операция, которая может быть получена из суперкласса в итоге наследования, определяется и в подклассе; это ее повторное определение "заслоняет" ее определение в суперклассе, так Способы создания и разрушения объектов что в подклассе применяется не унаследованная, а переопределенная в нем операция.

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

Для дополнения класса shape (фигура) классом circle (круг), довольно только объявления его в классе shape (без Способы создания и разрушения объектов конфигурации функций частей класса) в модуле shape.h и скомпилировать начальный текст в shape.obj. Таким макаром нет необходимости изменять начальный текст shape.c. Успешное создание потомков позволяет наращивать программку за счет скопления уже готовых текстов программ.

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

Объекты класса конструируются снизу ввысь: поначалу базисный, позже компоненты-объекты (если они имеются), а позже сам производный класс. Уничтожаются объекты в оборотном порядке: поначалу производный, позже его компоненты-объекты, а позже базисный объект.

Пример.

class Basiс {

int i; // сокрытие переменной

public:

Basis(int Способы создания и разрушения объектов x){ i=x; }

int GetI(void) {return I;} // получить значение сокрытой переменной

void SetI(int k) {i=k;} // установить значение сокрытой переменной

};

class Inherit: public Basis { // класс-наследник

int count;

public:

Inherit(int x,int c): Basis(x){ count=c; }

};


31,32,33.

Перегрузка унарных операций (УМК); Перегрузка бинарных операций (УМК);

Перегрузка и Способы создания и разрушения объектов переопределение операторов и функций. Пример реализации нескольких способов с схожим именованием в одном классе. (конспект лекций);

Одним из подходов реализации принципа полиморфизма в языке С++ является внедрение переопределения функций. В С++ две и поболее функций могут иметь одно и то же имя. Компилятор С++ оперирует не начальными именами функций Способы создания и разрушения объектов, а их внутренними представлениями, которые значительно отличаются от применяемых в программке. Эти имена содержат внутри себя скрытое описание типов аргументов. С этими же именами работают программки компоновщика и библиотекаря. По этой причине мы можем использовать функции с схожими именами, только типы аргументов у их должны быть различными. Конкретно на Способы создания и разрушения объектов этом и базирована реализация одной из особенностей полиморфизма. Заметим, что компилятор не различает функции по типу возвращаемого значения. Потому для компилятора функции с разным перечнем аргументов – это различные функции, а с схожим перечнем аргументов, но с различными типами возвращаемого значения - схожие. Для корректной работы программ последнего следует избегать. Разглядим обычный Способы создания и разрушения объектов пример переопределения функции sum, выполняющей сложение нескольких чисел разного типа.

#include "iostream.h"

Class cls

{ int n;

double f;

public:

cls(int N,float F) : n(N),f(F) {}

int sum(int); // функция sum с целочисленнным аргументом

double sum(double); // функция sum с дробным аргументом

void see(); // вывод содержимого объекта

};

int cls Способы создания и разрушения объектов:: sum(int k)

{ n+=k;

return n;

}

double cls:: sum(double k)

{ f+=k;

return f;

}

void cls:: see()

{cout <

void main()

{ cls obj(1,2.3);

obj.see(); // вывод содержимого объекта

cout <

cout <

}

Итог Способы создания и разрушения объектов работы программки:

1 2.3

3.3

В тоже время переопределение функций может создавать делему двусмысленности. К примеру:

Class A

{ . . .

public:

void fun(int i,long j) {cout<

void fun(long i,int j) { cout<

};

main()

{ A a;

a.fun(2,2); // ошибка непонятно какая из 2 функций вызывается

}

В данном случае появляется неоднозначность вызова функции fun Способы создания и разрушения объектов объекта a.

В ООП программер может определять смысл операций при их применении к объектам определенного класса. Не считая арифметических, можно определять к тому же логические операции, операции сопоставления, вызова () и индексирования [], также можно переопределять присваивание и инициализацию. Можно найти очевидное и неявное преобразование меж определяемыми юзером и основными типами.

Возможность Способы создания и разрушения объектов использовать знаки стандартных операций для записи выражений как для интегрированных, так и для абстрактных типов данных. В языке С++ для перегрузки операций употребляется ключевое слово operator, при помощи которого определяется особая операция-функция (operator function). Ее формат:

тип_возвр_значения operator знак_операции (специф_параметров)

{операторы_тела_функции Способы создания и разрушения объектов}

Перегрузка унарных операций. Неважно какая унарная операция Å может быть определена 2-мя методами: или как компонентная функция без характеристик, или как глобальная функция с одним параметром. В первом случае выражение ÅZ значит вызов Z.operatorÅ (), во 2-м - вызов operatorÅ(Z). Вызываемый объект класса автоматом воспринимается как операнд.

Пример.

class audio_player {

int Способы создания и разрушения объектов records_count;

int current_record;

...

public:

play(int i);

void init(void){ current_record = 0; }

void operator++ (){ //++a

current_record++;

if(current_record>records_count) current_record = 0;}

void operator++ (int i){ //a++

current_record++;

if(current_record>records_count) current_record = 0;}

void operator—(){ //--a

current_record--;

if(current_record<0) current_record = records_count - 1;}

} ;

void Способы создания и разрушения объектов main(){

audio_plajer a;

a.init();

++a;

a++;

}

Перегрузка бинарных операций. Неважно какая бинарная операция Å может быть определена 2-мя методами: или как функция-член класса с одним параметром, или как глобальная функция с 2-мя параметрами. В первом случае xÅy значит вызов x.operatorÅ (y), во 2-м Способы создания и разрушения объектов – вызов operatorÅ (x,y).

class Car{

int model; int year; int color;

public:

bool __fastcall operator== (Car& c){

return (model==c.model) && (year==c.year) && (color==c.color);}

} ;


28.Виртуальные функции. Раскройте смысл понятий «раннего» и «позднего» связывания в ООП (УМК, конспект лекций);

Ранее связывание имеет место в случае переопределяемых способов, когда Способы создания и разрушения объектов компилятор умеет отличать один вызов от другого по типу их аргументов. Используя эту информацию, он "агрессивно" связывает коды программки с надлежащими способами. Особенным случаем ранешнего связывания являются вызовы статических способов. К статическим данным и коду можно обращаться тогда и, когда объект класса еще не существует. Доступ к статическим членам Способы создания и разрушения объектов вероятен не только лишь через имя объекта, да и через имя класса:

имя_класса :: имя_компонента

Но так можно обращаться только к public членам. Для воззвания к private статической компоненте снаружи можно при помощи статических способов. Пример.

#include

class Car {

int speed;

static int CarCount; // статический атрибут – количество Способы создания и разрушения объектов машин

public:

Car(int s) {

speed = s;

CarCount++;

}

static int& count() {

return CarCount;

}

};

int Car::CarCount = 0; //инициализация статического атрибута

void main(void) {

Car c1(20); Car c2(30);

cout << ” Количество машин = “ << Car::count();

}

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

Виртуальные функции предоставляют механизм позднего (отложенного) либо динамического связывания. Неважно какая Способы создания и разрушения объектов нестатическая функция базисного класса может быть изготовлена виртуальной, зачем употребляется ключевое слово virtual:

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

Виртуальность наследуется. После того как функция определена как виртуальная, ее повторное определение в производном классе (с этим же самым макетом) делает в этом классе новейшую виртуальную Способы создания и разрушения объектов функцию, при этом спецификатор virtual может не употребляться.

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

virtual int funct1(void); // определение виртуальной функции

Принципиально осознавать, что виртуальные функции не могут быть статическими. Виртуальные функции могут не переопределяться в производных классах. В случае переопределения виртуальных функций, количество и типы Способы создания и разрушения объектов аргументов должны (с необходимостью) совпадать с определением базисной виртуальной функции. Переопределение тут равносильно подмене базисной (конкретно базисной) функции на другую. Можно обрисовать фукцию int Base::Fun(int) и int Derived::Fun(int) даже не виртуальную. В данном случае int Derived::Fun(int) гласит, что все другие версии функции Fun Способы создания и разрушения объектов(int), описанные в базисных класса, укрыты.


sposobi-uderzhaniya-vnimaniya-slushatelej.html
sposobi-umensheniya-i-uvelicheniya-davleniya.html
sposobi-upravleniya-i-razvitiya-pamyati-referat.html