In Java, C#, and VB .NET, the constructor creates reference type objects on the heap, whereas primitive types (such as int, double, etc.) are stored on the
stack (though some languages allow for manually allocating objects on the stack through a stackalloc modifier). VB .NET and C# also allow the use of the new operator to create value type objects, but these value type objects are created on the stack regardless of whether the operator is used or not. In these languages, object destruction occurs when the object has no references and then gets destroyed by the garbage collector. In C++, objects are created on the stack when the constructor is invoked without the new operator, and created on the heap when the constructor is invoked with the new operator (which returns a pointer to the object). Stack objects are deleted implicitly when they go out of scope, while heap objects must be deleted implicitly by a destructor or explicitly by using the delete operator. By using the "
Resource Acquisition is Initialization" (RAII) idiom, resource management can be greatly simplified. == Language details == Constructors are implemented in different
programming languages in various ways, including:
C In
C, there are no constructors. However, functions can be defined to create an object, similar to a constructor. • include typedef struct { char* name; int age; } Person; // this method creates an instance of Person Person* createPerson(const char name[], int age) { Person* p = (Person*)malloc(sizeof(Person)); if (!p) { return NULL; } strcpy(p->name, name); p->age = age; return p; } // this method destroys an instance of Person void destroyPerson(Person* p) { if (p) { free(p->name); free(p); } }
C++ In
C++, the name of the constructor is the name of the class. It returns nothing. It can have parameters like any
member function. Constructor functions are usually declared in the public section, but can also be declared in the protected and private sections, if the user wants to restrict access to them. The constructor has two parts. First is the
initializer list which follows the
parameter list and before the method body. It starts with a colon and entries are comma-separated. The initializer list is not required, but offers the opportunity to provide values for data members and avoid separate assignment statements. The initializer list is required if there are const or reference type data members, or members that do not have parameterless constructor logic. Assignments occur according to the order in which data members are declared (even if the order in the initializer list is different). The second part is the body, which is a normal method body enclosed in curly brackets. It is generally cheaper and better practice to use the initializer list as much as possible, and only use the constructor body for non-assignment operations and assignments where the initializer list cannot be used or is otherwise insufficient. C++ allows more than one constructor. The other constructors must have different parameters. Additionally constructors which contain parameters which are given default values, must adhere to the restriction that not all parameters are given a default value. This is a situation which only matters if there is a default constructor. The constructor of a
base class (or base classes) can also be called by a derived class. Constructor functions are not inherited and their addresses cannot be referenced. When memory allocation is required, the new and delete operators are called implicitly. A copy constructor has a parameter of the same type passed as const reference, for example MyClass(const MyClass& rhs). If it is not provided explicitly, the compiler uses the copy constructor for each member variable or simply copies values in case of primitive types. The default implementation is not efficient if the class has dynamically allocated members (or handles to other resources), because it can lead to double calls to delete (or double release of resources) upon destruction. import std; class PolarPoint { private: double x; double y; public: explicit PolarPoint(double r = 1.0, double theta = 0.0): // Constructor, parameters with default values. x{r * std::cos(theta)}, y{r * std::sin(theta)} /* Example invocations: PolarPoint a; PolarPoint b(3); PolarPoint c(5, std::numbers::pi / 4); On returning objects from functions or passing objects by value, the objects copy constructor will be called implicitly, unless
return value optimization applies. C++ implicitly generates a default copy constructor which will call the copy constructors for all base classes and all member variables unless the programmer provides one, explicitly deletes the copy constructor (to prevent cloning) or one of the base classes or member variables copy constructor is deleted or not accessible (private). Most cases calling for a customized
copy constructor (e.g.
reference counting,
deep copy of pointers) also require customizing the
destructor and the
copy assignment operator. This is commonly referred to as the
Rule of three.
C# Example
C# constructor: public class MyClass { private int a; private string b; // Constructor public MyClass() : this(42, "string") { } // Overloading a constructor public MyClass(int a, string b) { this.a = a; this.b = b; } } // Code somewhere // Instantiating an object with the constructor above MyClass c = new MyClass(42, "string"); Since C# 9.0, constructor calls can be further simplified using target-typed new expressions, which do not require naming the constructor when the type is already given. It will automatically call the constructor of the named type before the variable, but obviously will not resolve if using type deduction (var). // Above example with target-typed new expressions MyClass c = new(42, "string");
C# static constructor In
C#, a
static constructor is a static data initializer. Static constructors are also called
class constructors. Since the actual method generated has the name
.cctor they are often also called "cctors". Static constructors allow complex static variable initialization. Static constructors are called implicitly when the class is first accessed. Any call to a class (static or constructor call), triggers the static constructor execution. Static constructors are
thread safe and implement a
singleton pattern. When used in a
generic programming class, static constructors are called at every new generic instantiation one per type. CFML has also supported specifying the name of the constructor method: component initmethod="Cheese" { // properties property name="cheeseName"; // constructor function Cheese Cheese( required string cheeseName ) { variables.cheeseName = arguments.cheeseName; return this; } }
Crystal In Crystal, the user defines an initialize method, which the compiler uses to define a new method for allocating memory for the object and calling the user-defined method. The user can also manually define new or define an equivalent method with a different name, if desired (the code for both initialize and new is shown here). Although this snippet defines a class, the procedure is identical for Crystal structs. class Car # the initializer, which is an instance method. def initialize(make : String, year : Int) @make = make @year = year end # the allocator, which is a class method, denoted by the "self." prefix. # note that `new` takes the same arguments as `initialize` def self.new(make : String, year : Int) # allocate memory for the instance instance = Car.allocate # call the instance's initialize method using the provided parameters instance.initialize make, year # return the instance instance end end • instantiate a new `Car` like so: old_car = Car.new("Chevrolet", 1947)
Eiffel In
Eiffel, the routines which initialize new objects are called
creation procedures. Creation procedures have the following traits: • Creation procedures have no explicit return type (by definition of
procedure). • Creation procedures are named. • Creation procedures are designated by name as creation procedures in the text of the class. • Creation procedures can be explicitly invoked to re-initialize existing objects. • Every effective (i.e., concrete or non-abstract) class must designate at least one creation procedure. • Creation procedures must leave the newly initialized object in a state that satisfies the class invariant. Although object creation involves some subtleties, the creation of an attribute with a typical declaration x: T as expressed in a creation instruction create x.make consists of the following sequence of steps: • Create a new direct instance of type T. • Execute the creation procedure make to the newly created instance. • Attach the newly initialized object to the entity x. In the first snippet below, class POINT is defined. The procedure make is coded after the keyword feature. The keyword create introduces a list of procedures which can be used to initialize instances. In this case the list includes default_create, a procedure with an empty implementation inherited from class ANY, and the make procedure coded within the class. class POINT create default_create, make feature make (a_x_value: REAL; a_y_value: REAL) do x := a_x_value y := a_y_value end x: REAL -- X coordinate y: REAL -- Y coordinate ... In the second snippet, a class which is a client to POINT has a declarations my_point_1 and my_point_2 of type POINT. In procedural code, my_point_1 is created as the origin (0.0, 0.0). Because no creation procedure is specified, the procedure default_create inherited from class ANY is used. This line could have been coded create my_point_1.default_create . Only procedures named as creation procedures can be used in an instruction with the create keyword. Next is a creation instruction for my_point_2, providing initial values for the my_point_2's coordinates. The third instruction makes an ordinary instance call to the make procedure to reinitialize the instance attached to my_point_2 with different values. my_point_1: POINT my_point_2: POINT ... create my_point_1 create my_point_2.make (3.0, 4.0) my_point_2.make (5.0, 8.0) ...
F# In
F#, a constructor can include any let or do statements defined in a class. let statements define private fields and do statements execute code. Additional constructors can be defined using the new keyword. type MyClass(_a : int, _b : string) = class // Primary constructor let a = _a let b = _b do printfn "a = %i, b = %s" a b // Additional constructors new(_a : int) = MyClass(_a, "") then printfn "Integer parameter given" new(_b : string) = MyClass(0, _b) then printfn "String parameter given" new() = MyClass(0, "") then printfn "No parameter given" end // Code somewhere // instantiating an object with the primary constructor let c1 = new MyClass(42, "string") // instantiating an object with additional constructors let c2 = new MyClass(42) let c3 = new MyClass("string") let c4 = MyClass() // "new" keyword is optional
Java In
Java, constructors differ from other methods in that: • Constructors never have an explicit return type. • Constructors cannot be directly invoked (the keyword “new” invokes them). • Constructors should not have non-access modifiers. Java constructors perform the following tasks in the following order: • Call the default constructor of the superclass if no constructor is defined. • Initialize member variables to the specified values. • Executes the body of the constructor. Java permit users to call one constructor in another constructor using this() keyword. But this() must be first statement. class X { public X() { // Non-parameterized constructor this(1); // Calling of constructor System.out.println("Calling default constructor"); } public X(int a) { // Parameterized constructor System.out.println("Calling parameterized constructor"); } } public class Example { public static void main(String[] args) { X x = new X(); } } Java provides access to the
superclass's constructor through the super keyword. class X { // Declaration of instance variable(s). private int data; // Definition of the constructor. public X() { this(1); } // Overloading a constructor public X(int input) { data = input; // This is an assignment } } class Y extends X { private int data2; public Y() { super(); data2 = 1; } public Y(int input1, int input2) { super(input1); data2 = input2 } } public class Example { public static void main(String[] args) { Y y = new Y(42, 43); } } A constructor taking zero number of arguments is called a "no-arguments" or "no-arg" constructor.
JavaScript/TypeScript As of ES6,
JavaScript has direct constructors like many other programming languages. They are written as such class FooBar { constructor(baz) { this.baz = baz; } } This can be instantiated as such const foo = new FooBar('7'); The equivalent of this before ES6, was creating a function that instantiates an object as such function FooBar (baz) { this.baz = baz; } This is instantiated the same way as above. The
TypeScript equivalent of this would be: class FooBar { baz: string; constructor(baz: string) { this.baz = baz; } } const foo: FooBar = new FooBar('7');
Object Pascal In
Object Pascal, the constructor is similar to a
factory method. The only syntactic difference to regular methods is the keyword constructor in front of the name (instead of procedure or function). It can have any name, though the convention is to have Create as prefix, such as in CreateWithFormatting. Creating an instance of a class works like calling a static method of a class: TPerson.Create('Peter'). program OopProgram; type TPerson = class private FName: string; public property Name: string read FName; constructor Create(AName: string); end; constructor TPerson.Create(AName: string); begin FName := AName; end; var Person: TPerson; begin Person := TPerson.Create('Peter'); // allocates an instance of TPerson and then calls TPerson.Create with the parameter AName = 'Peter' end.
OCaml In
OCaml, there is one constructor. Parameters are defined right after the class name. They can be used to initialize instance variables and are accessible throughout the class. An anonymous hidden method called initializer allows to evaluate an expression immediately after the object has been built. class person first_name last_name = object val full_name = first_name ^ " " ^ last_name initializer print_endline("Hello there, I am " ^ full_name ^ ".") method get_last_name = last_name end;; let alonzo = new person "Alonzo" "Church" in (*Hello there, I am Alonzo Church.*) print_endline alonzo#get_last_name (*Church*)
PHP In
PHP version 5 and above, the constructor is a method named __construct() (notice that it's a double underscore), which the keyword new automatically calls after creating the object. It is usually used to automatically perform initializations such as property initializations. Constructors can also accept arguments, in which case, when the new statement is written, you also need to send the constructor arguments for the parameters. In the typical case, only the __init__ method need be defined. (The most common exception is for immutable objects.) class ExampleClass: def __new__(cls: type, value: int) -> 'ExampleClass': print("Creating new instance...") # Call the superclass constructor to create the instance. instance: 'ExampleClass' = super(ExampleClass, cls).__new__(cls) return instance def __init__(self, value: int) -> None: print("Initialising instance...") self.payload: int = value if __name__ == "__main__": exampleInstance: ExampleClass = ExampleClass(42) print(exampleInstance.payload) This prints: Creating new instance... Initialising instance... 42 Classes normally act as
factories for new instances of themselves, that is, a class is a callable object (like a function), with the call being the constructor, and calling the class returns an instance of that class. However the __new__ method is permitted to return something other than an instance of the class for specialised purposes. In that case, the __init__ is not invoked.
Raku In
Raku, even more boilerplate can be omitted, given that a default
new method is inherited, attributes can be specified, and whether they can be set, reset, or are required. In addition, any extra constructor functionality can be included in a
BUILD method which will get called to allow for custom initialization. A
TWEAK method can be specified to post-process any attributes already (implicitly) initialized. class Person { has Str $.first-name is required; # First name (a string) can only be set at # construction time (the . means "public"). has Str $.last-name is required; # Last name (a string) can only be set at # construction time (a ! would mean "private"). has Int $.age is rw; # Age (an integer) can be modified after # construction ('rw'), and is not required # during the object instantiation. # Create a 'full-name' method which returns the person's full name. # This method can be accessed outside the class. method full-name { $!first-name.tc ~ " " ~ $!last-name.tc } # Create a 'has-age' method which returns true if age has been set. # This method is used only inside the class so it's declared as "private" # by prepending its name with a ! method !has-age { self.age.defined } # Check custom requirements method TWEAK { if self!has-age && $!age The Person class is instantiated like this: my $p0 = Person.new( first-name => 'Sam', last-name => 'Ashe', age => 42 ); my $p1 = Person.new( first-name => 'grace', last-name => 'hopper' ); say $p1.full-name(); # OUTPUT: «Grace Hopper» Alternatively, the
named parameters can be specified using the colon-pair syntax in Perl 6: my $p0 = Person.new( :first-name, :last-name, :age(42) ); my $p1 = Person.new( :first-name, :last-name ); And should you have set up variables with names identical to the named parameters, you can use a shortcut that will use the
name of the variable for the named parameter: my $first-name = "Sam"; my $last-name = "Ashe"; my $age = 42; my $p0 = Person.new( :$first-name, :$last-name, :$age );
Ruby In
Ruby, constructors are created by defining a method called initialize. This method is executed to initialize each new instance. irb(main):001:0> class ExampleClass irb(main):002:1> def initialize irb(main):003:2> puts "Hello there" irb(main):004:2> end irb(main):005:1> end => nil irb(main):006:0> ExampleClass.new Hello there => #
Rust Rust does not have constructors in the sense of object-oriented programming, but often structs have a new() method that essentially acts as a constructor. The return type is usually indicated as Self. struct Point { x: i32, y: i32, } impl Point { pub fn new(x: i32, y: i32) -> Self { Point { x, y } } } fn main() { let p: Point = Point::new(10, 20); println!("Point is at ({}, {})", p.x, p.y); }
Visual Basic .NET In
Visual Basic .NET, constructors use a method declaration with the name "New". Class Foobar Private strData As String ' Constructor Public Sub New(ByVal someParam As String) strData = someParam End Sub End Class ' code somewhere else ' instantiating an object with the above constructor Dim foo As New Foobar(".NET") == See also ==