Войти
В объектно-ориентированном программировании (ООП) время жизни объекта (или жизненный цикл ) объекта - это время между созданием объекта и его уничтожением. Правила для времени жизни объекта значительно различаются между языками, в некоторых случаях между реализациями данного языка, и время жизни конкретного объекта может варьироваться от одного запуска программы к другому.
В некоторых случаях время жизни объекта совпадает с временем жизни переменной переменной с этим объектом в качестве значения (как для статических переменных, так и автоматических переменных ), но в целом время жизни объекта не привязано к времени жизни какой-либо одной переменной. Во многих случаях - и по умолчанию во многих объектно-ориентированных языках, особенно в тех, которые используют сборку мусора (GC) - объекты размещаются в куче, и время жизни объекта не определяется временем жизни данной переменной: значение переменной, содержащей объект, на самом деле соответствует ссылке на объект, а не самому объекту, а уничтожение переменной просто уничтожает ссылку, а не базовый объект.
Хотя основная идея времени жизни объекта проста - объект создается, используется, а затем уничтожается - детали существенно различаются между языками, и в реализациях данного языка, и тесно связано с тем, как реализовано управление памятью. Кроме того, проводится множество тонких различий между шагами, а также между концепциями уровня языка и концепциями уровня реализации. Терминология относительно стандартна, но то, какие шаги соответствуют данному термину, значительно различается в зависимости от языка.
Термины обычно идут в парах антонимов, один для концепции создания, другой для соответствующей концепции уничтожения, такой как инициализация / завершение или конструктор / деструктор. Пара создание / уничтожение также известна, среди прочего, как инициирование / завершение. Термины «выделение» и «освобождение» или «освобождение» также используются по аналогии с управлением памятью, хотя создание и уничтожение объектов может включать в себя значительно больше, чем просто выделение и освобождение памяти, а выделение / освобождение более правильно считать этапами создания и уничтожения соответственно.
Главное различие заключается в том, является ли время жизни объекта детерминированным или недетерминированным. Это зависит от языка и внутри языка зависит от выделения памяти объекта; время жизни объекта может отличаться от времени жизни переменной.
Объекты с распределением статической памяти, особенно объекты, хранящиеся в статических переменных, и классы модулей (если классы или модули сами являются объектами, и статически распределены), имеют тонкий недетерминизм во многих языках: хотя их время жизни, кажется, совпадает со временем выполнения программы, порядок создания и уничтожения - какой статический объект создается первым, какой второй и т. д. - обычно является недетерминированный.
Для объектов с автоматическим распределением памяти или динамическим распределением памяти создание объекта обычно происходит детерминированно, либо явно, когда объект явно создается (например, через newв C ++ или Java), или неявно в начале времени существования переменной, особенно когда вводится область автоматической переменной , например, при объявлении. Однако разрушение объектов различается - в некоторых языках, особенно в C ++, автоматические и динамические объекты уничтожаются в детерминированное время, например, при выходе из области видимости, явном уничтожении (через ручное управление памятью ) или счетчик ссылок достижение нуля; в то время как в других языках, таких как C #, Java и Python, эти объекты уничтожаются в недетерминированное время, в зависимости от сборщика мусора, и воскрешение объекта может происходить во время уничтожения, продлевая время жизни.
В языках со сборкой мусора объекты обычно выделяются динамически (в куче), даже если они изначально привязаны к автоматической переменной, в отличие от автоматических переменных с примитивными значениями, которые обычно выделяются автоматически (в стеке или в реестре). Это позволяет возвращать объект из функции («escape») без уничтожения. Однако в некоторых случаях возможна оптимизация компилятора, а именно выполнение анализа выхода и доказательство того, что выход невозможен, и, таким образом, объект может быть размещен в стеке; это важно в Java. В этом случае уничтожение объекта произойдет незамедлительно - возможно, даже во время жизни переменной (до конца ее области действия), если она недоступна.
Сложным случаем является использование пула объектов, где объекты могут быть созданы заранее или повторно использоваться, и, таким образом, очевидное создание и уничтожение может не соответствовать фактическому созданию и уничтожению объекта. объект, только (ре) инициализация для создания и финализация для уничтожения. В этом случае и создание, и разрушение могут быть недетерминированными.
Создание объекта можно разбить на две операции: выделение памяти и инициализация, где инициализация включает в себя присвоение значений полям объекта и, возможно, запуск произвольного другого кода. Это концепции уровня реализации, примерно аналогичные различию между объявлением и инициализацией (или определением) переменной, хотя позже они являются различиями на уровне языка. Для объекта, который привязан к переменной, объявление может быть скомпилировано для выделения памяти (резервирование места для объекта), а определение - для инициализации (присвоение значений), но объявления также могут быть предназначены только для использования компилятором (например, для разрешения имен), не соответствует непосредственно скомпилированному коду.
Аналогично уничтожение объекта можно разбить на две операции в обратном порядке: завершение и освобождение памяти. У них нет аналогичных концепций уровня языка для переменных: время жизни переменной заканчивается неявно (для автоматических переменных - при раскручивании стека; для статических переменных - при завершении программы), и в это время (или позже, в зависимости от реализации) память освобождается, но доработки в целом не делается. Однако, когда время жизни объекта привязано к времени жизни переменной, конец времени жизни переменной вызывает финализацию объекта; это стандартная парадигма C ++.
Вместе они дают четыре шага на уровне реализации:
Эти шаги могут выполняться автоматически средой выполнения языка, интерпретатором или виртуальной машиной или могут быть указаны вручную программистом в подпрограмме , конкретно с помощью методов - частота этого значительно варьируется между шагами и языками. Инициализация очень часто задается программистом в языках на основе классов, тогда как в строгих языках, основанных на прототипах, инициализация выполняется автоматически путем копирования. Финализация также очень распространена в языках с детерминированным разрушением, особенно в C ++, но гораздо реже в языках со сборкой мусора. Распределение указывается реже, а освобождение, как правило, не может быть указано.
Важной тонкостью является статус объекта во время создания или уничтожения, а также обработка случаев, когда возникают ошибки или возникают исключения, например, если создание или уничтожение не удалось. Строго говоря, время жизни объекта начинается, когда распределение завершается, и заканчивается, когда начинается освобождение. Таким образом, во время инициализации и финализации объект жив, но может не находиться в согласованном состоянии - обеспечение инвариантов класса является ключевой частью инициализации - и период с момента завершения инициализации до момента начала финализации - это когда объект одновременно активен и должен находиться в согласованном состоянии.
Если создание или уничтожение завершается неудачно, сообщение об ошибке (часто вызывая исключение) может быть затруднено: объект или связанные объекты могут находиться в несогласованном состоянии, а в случае разрушения, что обычно происходит неявно, и таким образом, в неопределенной среде - может быть трудно обрабатывать ошибки. Противоположная проблема - входящие исключения, а не исходящие исключения - заключается в том, должно ли создание или уничтожение вести себя по-разному, если они происходят во время обработки исключений, когда может быть желательно другое поведение.
Еще одна тонкость заключается в том, что создание и уничтожение происходят для статических переменных, срок жизни которых совпадает со временем выполнения программы - происходит ли создание и уничтожение во время обычного выполнения программы или на определенных этапах перед и после регулярного выполнения - и как объекты уничтожаются при завершении программы, когда программа может не находиться в обычном или непротиворечивом состоянии. Это особенно актуально для языков со сборкой мусора, так как они могут содержать много мусора при завершении программы.
В программировании на основе классов создание объекта также известно как создание экземпляра (создание экземпляра класса), а создание и уничтожение можно контролировать с помощью методов, известных как конструктор и деструктор или инициализатор и финализатор. Таким образом, создание и разрушение также известны как построение и разрушение, и когда эти методы вызываются, объект считается созданным или уничтоженным (не «уничтоженным») - соответственно, инициализируется или завершается при вызове этих методов.
Связь между этими методами может быть сложной, и язык может иметь как конструкторы, так и инициализаторы (например, Python), или деструкторы и финализаторы (например, C ++ / CLI ), или термины «деструктор» и «финализатор» могут относиться к конструкции уровня языка по сравнению с реализацией (как в C # по сравнению с CLI).
Ключевое различие заключается в том, что конструкторы являются методами класса, поскольку объект (экземпляр класса) недоступен до тех пор, пока объект не будет создан, но другие методы (деструкторы, инициализаторы и финализаторы) являются методами экземпляра, как объект создан. Кроме того, конструкторы и инициализаторы могут принимать аргументы, в то время как деструкторы и финализаторы обычно этого не делают, поскольку они обычно вызываются неявно.
В общем случае конструктор - это метод, явно вызываемый пользовательским кодом для создания объекта, а «деструктор» - это подпрограмма, вызываемая (обычно неявно, но иногда явно) при уничтожении объекта в языках с детерминированным объектом. время жизни - архетип - C ++ - и «финализатор» - это подпрограмма, неявно вызываемая сборщиком мусора при уничтожении объекта в языках с недетерминированным временем жизни объекта - архетип - Java.
Шаги во время завершения значительно различаются в зависимости от управления памятью: при ручном управлении памятью (как в C ++ или ручном подсчете ссылок), ссылки должны быть явно уничтожены программистом (ссылки очищены, счетчик ссылок уменьшен); при автоматическом подсчете ссылок это также происходит во время финализации, но автоматически (как в Python, когда это происходит после вызова финализаторов, указанных программистом); и при отслеживании сборки мусора в этом нет необходимости. Таким образом, при автоматическом подсчете ссылок финализаторы, указанные программистом, часто бывают короткими или отсутствуют, но все же может быть проделана значительная работа, в то время как при трассировке сборщиков мусора финализация часто не требуется.
В языках, где объекты имеют детерминированное время жизни, время жизни объекта может использоваться для совмещения управления ресурсами : это называется Инициализация получения ресурсов (RAII) идиома: ресурсы получаются во время инициализации и освобождаются во время завершения. В языках, где объекты имеют недетерминированное время жизни, в частности из-за сборки мусора, управление памятью обычно осуществляется отдельно от управления другими ресурсами.
В типичном случае процесс выглядит следующим образом:
Эти задачи могут быть выполнены сразу, но иногда остаются незавершенными, а порядок выполнения задач может варьироваться и может вызывать несколько странных действий. Например, в множественном наследовании, какой код инициализации должен быть вызван первым, является трудным вопросом. Однако конструкторы суперкласса должны вызываться перед конструкторами подкласса.
Создание каждого объекта как элемента массива - сложная задача. Некоторые языки (например, C ++) оставляют это программистам.
Обработка исключений в процессе создания объекта особенно проблематична, потому что обычно реализация генерации исключений зависит от допустимых состояний объекта. Например, невозможно выделить новое пространство для объекта исключения, если выделение объекта не удалось до этого из-за нехватки свободного места в памяти. По этой причине реализации объектно-ориентированных языков должны обеспечивать механизмы, позволяющие вызывать исключения даже при нехватке ресурсов, а программисты или система типов должны гарантировать, что их код безопасен для исключений. Распространение исключения с большей вероятностью освободит ресурсы, чем выделит их. Но в объектно-ориентированном программировании создание объекта может завершиться ошибкой, поскольку при построении объекта должны устанавливаться инварианты класса , которые часто не действительны для каждой комбинации аргументов конструктора. Таким образом, конструкторы могут вызывать исключения.
Шаблон абстрактной фабрики - это способ отделить конкретную реализацию объекта от кода для создания такого объекта.
Способ создания объектов зависит от языка. В некоторых языках, основанных на классах, специальный метод, известный как конструктор , отвечает за проверку состояния объекта. Как и обычные методы, конструкторы могут быть перегружены, чтобы можно было создать объект с указанными различными атрибутами. Кроме того, конструктор - единственное место, где можно установить состояние неизменяемых объектов. Конструктор копирования - это конструктор, который принимает (единственный) параметр существующего объекта того же типа, что и класс конструктора, и возвращает копию объекта, отправленного в качестве параметра.
Другие языки программирования, такие как Objective-C, имеют методы класса, которые могут включать в себя методы типа конструктора, но не ограничиваются простым созданием экземпляров объектов.
C ++ и Java подверглись критике за то, что не предоставляют именованные конструкторы - конструктор всегда должен иметь то же имя, что и класс. Это может быть проблематично, если программист хочет предоставить два конструктора с одинаковыми типами аргументов, например, для создания точечного объекта либо из декартовых координат, либо из полярных координат, оба из который будет представлен двумя числами с плавающей запятой. Objective-C может обойти эту проблему, поскольку программист может создать класс Point с методами инициализации, например, + newPointWithX: andY:и + newPointWithR: andTheta:. В C ++ нечто подобное можно сделать с помощью статических функций-членов.
Конструктор также может ссылаться на функцию, которая используется для создания значения помеченного объединения, особенно в функциональных языках.
Обычно после использования объект удаляется из памяти, чтобы освободить место для других программ или объектов, которые могут занять место этого объекта. Однако, если памяти достаточно или программа имеет короткое время выполнения, разрушение объекта может не произойти, память просто освобождается при завершении процесса. В некоторых случаях уничтожение объекта просто заключается в освобождении памяти, особенно в языках со сборкой мусора, или если «объект» на самом деле является простой старой структурой данных. В других случаях перед освобождением выполняется некоторая работа, в частности, уничтожение объектов-членов (при ручном управлении памятью) или удаление ссылок из объекта на другие объекты для уменьшения счетчика ссылок (при подсчете ссылок). Это может быть автоматическое действие, либо для объекта может быть вызван специальный метод уничтожения.
В языках на основе классов с детерминированным временем существования объекта, в частности в C ++, деструктор - это метод, вызываемый при удалении экземпляра класса перед удалением памяти. освобожден. В C ++ деструкторы отличаются от конструкторов по-разному: они не могут быть перегружены, не должны иметь аргументов, не должны поддерживать инварианты класса и могут вызывать завершение программы, если они вызывают исключения.
В языках сбора мусора объекты могут быть уничтожены, когда они больше не могут быть доступны для работающего кода. В языках с GC на основе классов аналогом деструкторов являются финализаторы, которые вызываются перед сборкой объекта сборщиком мусора. Они отличаются тем, что работают в непредсказуемое время и в непредсказуемом порядке, поскольку сборка мусора непредсказуема, а также значительно реже и менее сложна, чем деструкторы C ++. Примеры таких языков включают Java, Python и Ruby.
. Уничтожение объекта приведет к тому, что любые ссылки на объект станут недействительными, а при ручном управлении памятью любые существующие ссылки становятся висячими ссылками. При сборке мусора (как при отслеживании сборки мусора, так и при подсчете ссылок) объекты уничтожаются только тогда, когда на них нет ссылок, но финализация может создавать новые ссылки на объект, и для предотвращения висящих ссылок происходит воскрешение объекта так что ссылки остаются в силе.
class Foo {public: // Это объявления прототипов конструкторов. Foo (int x); Foo (int x, int y); // Перегруженный конструктор. Foo (const Foo старый); // Копируем конструктор. ~ Foo (); // Деструктор. }; Foo :: Foo (int x) {// Это реализация // конструктора с одним аргументом. } Foo :: Foo (int x, int y) {// Это реализация // конструктора с двумя аргументами. } Foo :: Foo (const Foo old) {// Это реализация // конструктора копирования. } Foo :: ~ Foo () {// Это реализация деструктора. } int main () {Foo foo (14); // Вызов первого конструктора. Foo foo2 (12, 16); // Вызов перегруженного конструктора. Foo foo3 (foo); // Вызов конструктора копирования. // Деструкторы вызываются в обратном порядке // здесь автоматически. }class Foo {public Foo (int x) {// Это реализация // конструктора с одним аргументом} public Foo (int x, int y) {// Это реализация // конструктор с двумя аргументами} public Foo (Foo old) {// Это реализация // конструктора копирования} public static void main (String args) {Foo foo = new Foo (14); // вызов первого конструктора Foo foo2 = new Foo (12, 16); // вызов перегруженного конструктора Foo foo3 = new Foo (foo); // вызов конструктора копирования // сборка мусора происходит под покровом, а объекты уничтожаются}}namespace ObjectLifeTime {class Foo {public Foo () {// Это реализация конструктора по умолчанию. } public Foo (int x) {// Это реализация // конструктора с одним аргументом. } ~ Foo () {// Это реализация // деструктора. } public Foo (int x, int y) {// Это реализация // конструктора с двумя аргументами. } public Foo (Foo old) {// Это реализация // конструктора копирования. } public static void Main (строковые аргументы) {Foo defaultfoo = new Foo (); // Вызов конструктора по умолчанию Foo foo = new Foo (14); // Вызов первого конструктора Foo foo2 = new Foo (12, 16); // Вызов перегруженного конструктора Foo foo3 = new Foo (foo); // Вызов конструктора копирования}}}#import@interface Point: Object {double x; двойной y; } // Это методы класса; мы объявили два конструктора + (Point *) newWithX: (double) иY: (double); + (Точка *) newWithR: (двойной) andTheta: (двойной); // Методы экземпляра - (Point *) setFirstCoord: (double); - (Точка *) setSecondCoord: (двойной); / * Так как Point является подклассом общего класса Object *, мы уже получили общие методы выделения и инициализации *, + alloc и -init. Для наших конкретных конструкторов * мы можем создать их из унаследованных * методов. * / @end @implementation Point - (Point *) setFirstCoord: (двойной) new_val {x = new_val; } - (Точка *) setSecondCoord: (double) new_val {y = new_val; } + (Point *) newWithX: (double) x_val andY: (double) y_val {// Лаконично написанный метод класса для автоматического выделения и // выполнения определенной инициализации. return [[[Распределение точек] setFirstCoord: x_val] setSecondCoord: y_val]; } + (Point *) newWithR: (double) r_val andTheta: (double) theta_val {// Вместо того, чтобы выполнять то же самое, что и выше, мы можем коварно // использовать тот же результат, что и предыдущий метод return [Point newWithX: r_val andY : theta_val]; } @end int main (void) {// Строит две точки p и q. Point * p = [Point newWithX: 4.0 andY: 5.0]; Point * q = [Point newWithR: 1.0 andTheta: 2.28]; //... текст программы.... // Мы закончили с p, скажем так, освободите его. // Если p выделяет больше памяти для себя, может потребоваться // переопределить метод Object free, чтобы // рекурсивно освободить память p. Но это не так, поэтому мы можем просто [p free]; //... больше текста... [q free]; возврат 0; }
Связанные языки: «Delphi», «Free Pascal», «Mac Pascal».
пример программы; тип DimensionEnum = (deUnassigned, de2D, de3D, de4D); PointClass = частный класс Dimension: DimensionEnum; общедоступный X: целое число; Y: целое число; Z: целое число; T: целое число; общедоступный (* прототип конструкторов *) конструктор Create (); конструктор Create (AX, AY: Integer); конструктор Create (AX, AY, AZ: Integer); конструктор Create (AX, AY, AZ, ATime: Integer); конструктор CreateCopy (APoint: PointClass); (* прототип деструкторов *) деструктор Destroy; конец; конструктор PointClass.Create (); begin // реализация универсального конструктора без аргументов Self.Dimension: = deUnassigned; конец; конструктор PointClass.Create (AX, AY: Integer); begin // реализация конструктора с двумя аргументами Self.X: = AX; Y: = AY; Собственные размеры: = de2D; конец; конструктор PointClass.Create (AX, AY, AZ: Integer); begin // реализация конструктора с 3 аргументами Self.X: = AX; Y: = AY; Self.X: = AZ; Собственные размеры: = de3D; конец; конструктор PointClass.Create (AX, AY, AZ, ATime: Integer); begin // реализация конструктора с 4 аргументами Self.X: = AX; Y: = AY; Self.X: = AZ; T: = ATime; Собственный размер: = de4D; конец; конструктор PointClass.CreateCopy (APoint: PointClass); begin // реализация "копирующего" конструктора APoint.X: = AX; APoint.Y: = AY; APoint.X: = AZ; APoint.T: = ATime; Собственный размер: = de4D; конец; деструктор PointClass.PointClass.Destroy; begin // реализация универсального деструктора без аргументов Self.Dimension: = deUnAssigned; конец; var (* переменная для статического распределения *) S: PointClass; (* переменная для динамического размещения *) D: ^ PointClass; begin (* программы *) (* линия жизни объекта со статическим размещением *) S.Create (5, 7); (* сделать что-нибудь с "S" *) S.Destroy; (* линия жизни объекта с динамическим размещением *) D = new PointClass, Create (5, 7); (* сделать что-нибудь с "D" *) dispose D, Destroy; конец. (* программы *)
class Socket (object): def __init __ (self, remote_host: str) ->None: # подключиться к удаленному хосту def send (self): # Отправить данные def recv (self): # Получение данных def close (self): # закрытие сокета def __del __ (self): # __del__ волшебная функция, вызываемая, когда счетчик ссылок объекта равен нулю self.close () def f (): socket = Socket ("example. com ") socket.send (" test ") return socket.recv ()Сокет будет закрыт на следующем этапе сборки мусора после выполнения и возврата функции" f ", поскольку все ссылки на него были потеряны.
