در برنامه‌نویسی شی گرا (OOP)، **طول عمر شی** (به انگلیسی: Object lifetime) (یا **چرخه حیات**) یک شی، زمان بین ایجاد یک شی و تخریب آن است. قوانین مربوط به طول عمر شی بین زبان‌ها به‌طور قابل توجهی متفاوت است، در برخی موارد بین پیاده‌سازی‌های یک زبان خاص، و طول عمر یک شی خاص ممکن است از یک اجرای برنامه به برنامه دیگر متفاوت باشد.

در برخی موارد، طول عمر شی با طول عمر متغیر یک متغیر با آن شی به عنوان مقدار مطابقت دارد (هم برای متغیرهای استاتیک و هم برای متغیرهای خودکار)، اما به‌طور کلی طول عمر شی به طول عمر هیچ‌یک از متغیرها وابسته نیست. در بسیاری از موارد - و به‌طور پیش‌فرض در بسیاری از زبان‌های شی‌گرا، به‌ویژه آن‌هایی که از جمع‌آوری زباله (GC) استفاده می‌کنند - اشیا روی پشته تخصیص داده می‌شوند و طول عمر شی با طول عمر یک متغیر معین تعیین نمی‌شود: مقدار یک متغیر. نگه داشتن یک شی در واقع مربوط به ارجاع به شی است، نه خود شی، و تخریب متغیر فقط مرجع را از بین می‌برد، نه شی زیربنایی.

مثال‌ها
-------

### C++

```
class Foo {
 public:
 // These are the prototype declarations of the constructors.
 Foo(int x);
 Foo(int x, int y); // Overloaded Constructor.
 Foo(const Foo &old); // Copy Constructor.
 ~Foo(); // Destructor.
};

Foo::Foo(int x) {
 // This is the implementation of
 // the one-argument constructor.
}

Foo::Foo(int x, int y) {
 // This is the implementation of
 // the two-argument constructor.
}

Foo::Foo(const Foo &old) {
 // This is the implementation of
 // the copy constructor.
}

Foo::~Foo() {
 // This is the implementation of the destructor.
}

int main() {
 Foo foo(14); // Call first constructor.
 Foo foo2(12, 16); // Call overloaded constructor.
 Foo foo3(foo); // Call the copy constructor.

 // Destructors called in backwards-order
 // here, automatically.
}

```

### Java

```
class Foo
{
 public Foo(int x)
 {
 // This is the implementation of
 // the one-argument constructor
 }

 public Foo(int x, int y)
 {
 // This is the implementation of
 // the two-argument constructor
 }

 public Foo(Foo old)
 {
 // This is the implementation of
 // the copy constructor
 }

 public static void main(String[] args)
 {
 Foo foo = new Foo(14); // call first constructor
 Foo foo2 = new Foo(12, 16); // call overloaded constructor
 Foo foo3 = new Foo(foo); // call the copy constructor
 // garbage collection happens under the covers, and objects are destroyed
 }
}

```

### C

```
namespace ObjectLifeTime;

class Foo
{
 public Foo()
 {
 // This is the implementation of
 // default constructor.
 }

 public Foo(int x)
 {
 // This is the implementation of
 // the one-argument constructor.
 }
 ~Foo()
 {
 // This is the implementation of
 // the destructor.
 }

 public Foo(int x, int y)
 {
 // This is the implementation of
 // the two-argument constructor.
 }

 public Foo(Foo old)
 {
 // This is the implementation of
 // the copy constructor.
 }

 public static void Main(string[] args)
 {
 var defaultfoo = new Foo(); // Call default constructor
 var foo = new Foo(14); // Call first constructor
 var foo2 = new Foo(12, 16); // Call overloaded constructor
 var foo3 = new Foo(foo); // Call the copy constructor
 }
}

```

### Objective-C

```
#import <objc/Object.h>

@interface Point : Object
{
 double x;
 double y;
}

//These are the class methods; we have declared two constructors
+ (Point \*) newWithX: (double) andY: (double);
+ (Point \*) newWithR: (double) andTheta: (double);

//Instance methods
- (Point \*) setFirstCoord: (double);
- (Point \*) setSecondCoord: (double);

/\* Since Point is a subclass of the generic Object
 \* class, we already gain generic allocation and initialization
 \* methods, +alloc and -init. For our specific constructors
 \* we can make these from these methods we have
 \* inherited.
 \*/
@end

@implementation Point

- (Point \*) setFirstCoord: (double) new\_val
{
 x = new\_val;
}

- (Point \*) setSecondCoord: (double) new\_val
{
 y = new\_val;
}

+ (Point \*) newWithX: (double) x\_val andY: (double) y\_val
{
 //Concisely written class method to automatically allocate and
 //perform specific initialization.
 return [[[Point alloc] setFirstCoord:x\_val] setSecondCoord:y\_val];
}

+ (Point \*) newWithR: (double) r\_val andTheta: (double) theta\_val
{
 //Instead of performing the same as the above, we can underhandedly
 //use the same result of the previous method
 return [Point newWithX:r\_val andY:theta\_val];
}

@end

int
main(void)
{
 //Constructs two points, p and q.
 Point \*p = [Point newWithX:4.0 andY:5.0];
 Point \*q = [Point newWithR:1.0 andTheta:2.28];

 //...program text....

 //We're finished with p, say, so, free it.
 //If p allocates more memory for itself, may need to
 //override Object's free method in order to recursively
 //free p's memory. But this is not the case, so we can just
 [p free];

 //...more text...

 [q free];

 return 0;
}

```

### Object Pascal

زبان‌های مرتبط: "Delphi", "Free Pascal", "Mac Pascal".

```
program Example;

type

 DimensionEnum =
 (
 deUnassigned,
 de2D,
 de3D,
 de4D
 );

 PointClass = class
 private
 Dimension: DimensionEnum;

 public
 X: Integer;
 Y: Integer;
 Z: Integer;
 T: Integer;

 public
 (\* prototype of constructors \*)

 constructor Create();
 constructor Create(AX, AY: Integer);
 constructor Create(AX, AY, AZ: Integer);
 constructor Create(AX, AY, AZ, ATime: Integer);
 constructor CreateCopy(APoint: PointClass);

 (\* prototype of destructors \*)

 destructor Destroy;
 end;

constructor PointClass.Create();
begin
 // implementation of a generic, non argument constructor
 Self.Dimension := deUnassigned;
end;

constructor PointClass.Create(AX, AY: Integer);
begin
 // implementation of a, 2 argument constructor
 Self.X := AX;
 Y := AY;

 Self.Dimension := de2D;
end;

constructor PointClass.Create(AX, AY, AZ: Integer);
begin
 // implementation of a, 3 argument constructor
 Self.X := AX;
 Y := AY;
 Self.X := AZ;

 Self.Dimension := de3D;
end;

constructor PointClass.Create(AX, AY, AZ, ATime: Integer);
begin
 // implementation of a, 4 argument constructor
 Self.X := AX;
 Y := AY;
 Self.X := AZ;
 T := ATime;

 Self.Dimension := de4D;
end;

constructor PointClass.CreateCopy(APoint: PointClass);
begin
 // implementation of a, "copy" constructor
 APoint.X := AX;
 APoint.Y := AY;
 APoint.X := AZ;
 APoint.T := ATime;

 Self.Dimension := de4D;
end;

destructor PointClass.PointClass.Destroy;
begin
 // implementation of a generic, non argument destructor
 Self.Dimension := deUnAssigned;
end;

var
 (\* variable for static allocation \*)
 S: PointClass;
 (\* variable for dynamic allocation \*)
 D: ^PointClass;

begin (\* of program \*)
 (\* object lifeline with static allocation \*)
 S.Create(5, 7);

 (\* do something with "S" \*)

 S.Destroy;

 (\* object lifeline with dynamic allocation \*)
 D = new PointClass, Create(5, 7);

 (\* do something with "D" \*)

 dispose D, Destroy;
end. (\* of program \*)

```

### Python

```
class Socket:
    def \_\_init\_\_(self, remote\_host: str) -> None:
        # connect to remote host

    def send(self):
        # Send data

    def recv(self):
        # Receive data

    def close(self):
        # close the socket

    def \_\_del\_\_(self):
        # \_\_del\_\_ magic function called when the object's reference count equals zero
        self.close()

def f():
    socket = Socket("example.com")
    socket.send("test")
    return socket.recv()

```

سوکت در دور بعدی جمع‌آوری زباله پس از اجرا و بازگشت تابع «f» بسته می‌شود، زیرا همه مراجع به آن از بین رفته‌اند.