✨Vòng đời đối tượng

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 constructo

return 0;
// destructors called in backwards-order
// here, automatically

}

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
}

}

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)
{
    Foo defaultfoo = new Foo(); // call default constructor
    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

}

} }

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 )

def send(self):
    # send data

def recv(self):
    # receive data;

def f(): s = Socket('example.com') s.send('test') return s.recv()