طولعمر شی
در برنامهنویسی شی گرا (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» بسته میشود، زیرا همه مراجع به آن از بین رفتهاند.
منابع
ویرایش- مشارکتکنندگان ویکیپدیا. «Object lifetime». در دانشنامهٔ ویکیپدیای انگلیسی، بازبینیشده در ۲۰ ژانویهٔ ۲۰۲۴.