طول‌عمر شی کیست؟ توضیح بده.
در برنامه‌نویسی شی گرا (OOP)، طول عمر شی (یا چرخه حیات) یک شی، زمان بین ایجاد یک شی و تخریب آن است. قوانین مربوط به طول عمر شی بین زبان‌ها به‌طور قابل توجهی متفاوت است، در برخی موارد بین پیاده‌سازی‌های یک زبان خاص، و طول عمر یک شی خاص ممکن است از یک اجرای برنامه به برنامه دیگر متفاوت باشد.در برخی موارد، طول عمر شی با طول عمر متغیر یک متغیر با آن شی به عنوان مقدار مطابقت دارد (هم برای متغیرهای استاتیک و هم برای متغیرهای خودکار)، اما به‌طور کلی طول عمر شی به طول عمر هیچ‌یک از متغیرها وابسته نیست. در بسیاری از موارد - و به‌طور پیش‌فرض در بسیاری از زبان‌های شی‌گرا، به‌ویژه آن‌هایی که از جمع‌آوری زباله (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 &amp;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 &amp;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 destroyedC.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 constructorObjective-C.@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];@endintmain(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) -&gt; 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» بسته می‌شود، زیرا همه مراجع به آن از بین رفته‌اند.منابع.[[رده:شیء (علوم رایانه)]]