Inclass-based,object-oriented programming, aconstructor (abbreviation:ctor) is a special type offunction called tocreate an object. It prepares the new object for use, often acceptingarguments that the constructor uses to set requiredmember variables.
A constructor resembles aninstance method, but it differs from a method in that it has no explicitreturn type, it is not implicitlyinherited and it usually has different rules for scope modifiers. Constructors often have the same name as the declaringclass. They have the task ofinitializing the object'sdata members and of establishing theinvariant of the class, failing if the invariant is invalid. A properly written constructor leaves the resultingobject in avalid state.Immutable objects must be initialized in a constructor.
Most languages allowoverloading the constructor in that there can be more than one constructor for a class, with differing parameters. Some languages take consideration of some special types of constructors. Constructors, which concretely use a single class to create objects and return a new instance of the class, are abstracted byfactories, which also create objects but can do so in various ways, using multiple classes or different allocation schemes such as anobject pool.
Constructors that can take at least one argument are termed as parameterized constructors. When an object is declared in a parameterized constructor, the initial values have to be passed as arguments to the constructor function. The normal way of object declaration may not work. The constructors can be called explicitly or implicitly. The method of calling the constructor implicitly is also called the shorthand method.
classExample{public:Example();Example(inta,intb);// Parameterized constructor.private:intx_;inty_;};Example::Example()=default;Example::Example(intx,inty):x_(x),y_(y){}
Examplee=Example(0,50);// Explicit call.Examplee2(0,50);// Implicit call.
If the programmer does not supply a constructor for an instantiable class, Java compiler inserts adefault constructor into your code on your behalf. This constructor is known as default constructor. You would not find it in your source code (the java file) as it would be inserted into the code during compilation and exists in .class file. The behavior of the default constructor is language dependent. It may initialize data members to zero or other same values, or it may do nothing at all. In Java, a "default constructor" refer to a nullary constructor that is automatically generated by the compiler if no constructors have been defined for the class or in the absence of any programmer-defined constructors (e.g. in Java, the default constructor implicitly calls thesuperclass'snullary constructor, then executes an empty body). All fields are left at their initial value of 0 (integer types), 0.0 (floating-point types), false (boolean type), or null (reference types)...
#include<iostream>classStudent{public:Student(inta=0,intb=0);// Default constructor.inta;intb;};
Like C++, Java also supports "Copy Constructor". But, unlike C++, Java doesn't create a default copy constructor if you don't write your own. Copy constructors define the actions performed by the compiler when copying class objects. A Copy constructor has one formal parameter that is the type of the class (the parameter may be a reference to an object). It is used to create a copy of an existing object of the same class. Even though both classes are the same, it counts as a conversion constructor.While copy constructors are usually abbreviated copy ctor or cctor, they have nothing to do with class constructors used in.NET using the same abbreviation.
Conversion constructors provide a means for a compiler to implicitly create an object belonging to one class based on an object of a different type. These constructors are usually invoked implicitly to convert arguments or operands to an appropriate type, but they may also be called explicitly.
In C++,move constructors take an Rvalue reference to an object of the class, and are used to implement ownership transfer of the parameter object's resources.
__construct. For backwards compatibility, a method with the same name as the class will be called if__construct method can not be found. Since PHP 5.3.3, this works only for non-namespaced classes.[1]__construct. Methods with the same name as the class will trigger an E_DEPRECATED level error.[1]New".__new__" and "__init__". The__new__ method is responsible for allocating memory for the instance, and receives the class as an argument (conventionally called "cls"). The__init__ method (often called "the initialiser") is passed the newly created instance as an argument (conventionally called "self").[2]constructor" and can have user-defined names (but are mostly called "Create").alloc" and "init" with thealloc method setting aside (allocating) memory for an instance of the class, and theinit method handling the bulk of initializing the instance. A call to the method "new" invokes both thealloc and theinit methods, for the class instance.In Java, C#, and VB .NET, the constructor creates reference type objects in a special memory structure called the"heap". Value types (such as int, double, etc.) are created in a sequential structure called the "stack".VB .NET and C# also allow the use of thenew 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 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. 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 thedelete operator.
Constructors are implemented in differentprogramming languages in various ways, including:
InC++, the name of the constructor is the name of the class. It returns nothing. It can have parameters like anymember 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 theinitializer list which follows theparameter 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 you haveconst 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).[3] The second part is the body, which is a normal method body enclosed in curly brackets.
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 abase 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, thenew anddelete operators are called implicitly.
A copy constructor has a parameter of the same type passed asconst reference, for exampleVector(const Vector& 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 todelete (or double release of resources) upon destruction.
classFoobar{public:Foobar(doubler=1.0,doublealpha=0.0)// Constructor, parameters with default values.:x_(r*cos(alpha))// <- Initializer list{y_=r*sin(alpha);// <- Normal assignment}private:doublex_;doubley_;};
Example invocations:
Foobara,b(3),c(5,M_PI/4);
On returning objects from functions or passing objects by value, the objects copy constructor will be called implicitly, unlessreturn 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 customizedcopy constructor (e.g.reference counting,deep copy of pointers) also require customizing thedestructor and thecopy assignment operator. This is commonly referred to as theRule of three.
ExampleC# constructor:
publicclassMyClass{privateinta;privatestringb;// ConstructorpublicMyClass():this(42,"string"){}// Overloading a constructorpublicMyClass(inta,stringb){this.a=a;this.b=b;}}
// Code somewhere// Instantiating an object with the constructor aboveMyClassc=newMyClass(42,"string");
InC#, astatic constructor is a static data initializer.[4]: 111–112 Static constructors are also calledclass constructors. Since the actual method generated has the name.cctor they are often also called "cctors".[5][6]
Static constructors allow complex static variable initialization.[7]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 arethread safe and implement asingleton pattern. When used in ageneric programming class, static constructors are called at every new generic instantiation one per type.[8]: 38 [4]: 111 Static variables are instantiated as well.
publicclassMyClass{privatestaticint_A;// Normal constructorstaticMyClass(){_A=32;}// Standard default constructorpublicMyClass(){}}
// Code somewhere// Instantiating an object with the constructor above// right before the instantiation// The variable static constructor is executed and _A is 32MyClassc=newMyClass();
ColdFusion Markup Language (CFML) uses a method named 'init' as a constructor method.
Cheese.cfc
component{// propertiespropertyname="cheeseName";// constructorfunctionCheeseinit(requiredstringcheeseName){variables.cheeseName=arguments.cheeseName;returnthis;}}
Create instance of a cheese.
myCheese=newCheese('Cheddar');
Since ColdFusion 10,[9] CFML has also supported specifying the name of the constructor method:
componentinitmethod="Cheese"{// propertiespropertyname="cheeseName";// constructorfunctionCheeseCheese(requiredstringcheeseName){variables.cheeseName=arguments.cheeseName;returnthis;}}
InEiffel, the routines which initialize new objects are calledcreation procedures. Creation procedures have the following traits:
Although object creation involves some subtleties,[10] the creation of an attribute with a typical declarationx: T as expressed in a creation instructioncreate x.make consists of the following sequence of steps:
T.[c]make to the newly created instance.x.In the first snippet below, classPOINT is defined. The proceduremake is coded after the keywordfeature.
The keywordcreate introduces a list of procedures which can be used to initialize instances. In this case the list includesdefault_create, a procedure with an empty implementation inherited from classANY, and themake procedure coded within the class.
classPOINTcreatedefault_create,makefeaturemake(a_x_value:REAL;a_y_value:REAL)dox:=a_x_valuey:=a_y_valueendx:REAL-- X coordinatey:REAL-- Y coordinate...
In the second snippet, a class which is a client toPOINT has a declarationsmy_point_1 andmy_point_2 of typePOINT.
In procedural code,my_point_1 is created as the origin (0.0, 0.0). Because no creation procedure is specified, the proceduredefault_create inherited from classANY is used. This line could have been codedcreate my_point_1.default_create .Only procedures named as creation procedures can be used in an instruction with thecreate keyword.Next is a creation instruction formy_point_2, providing initial values for themy_point_2's coordinates.The third instruction makes an ordinary instance call to themake procedure to reinitialize the instance attached tomy_point_2 with different values.
my_point_1:POINTmy_point_2:POINT...createmy_point_1createmy_point_2.make(3.0,4.0)my_point_2.make(5.0,8.0)...
InF#, a constructor can include anylet ordo statements defined in a class.let statements define private fields anddo statements execute code. Additional constructors can be defined using thenew keyword.
typeMyClass(_a:int,_b:string)=class// Primary constructorleta=_aletb=_bdoprintfn"a = %i, b = %s"ab// Additional constructorsnew(_a:int)=MyClass(_a,"")thenprintfn"Integer parameter given"new(_b:string)=MyClass(0,_b)thenprintfn"String parameter given"new()=MyClass(0,"")thenprintfn"No parameter given"end
// Code somewhere// instantiating an object with the primary constructorletc1=newMyClass(42,"string")// instantiating an object with additional constructorsletc2=newMyClass(42)letc3=newMyClass("string")letc4=MyClass()// "new" keyword is optional
InJava, constructors differ from other methods in that:
new” invokes them).Java constructors perform the following tasks in the following order:
Java permit users to call one constructor in another constructor usingthis() keyword.Butthis() must be first statement.[11]
classExample{Example()// Non-parameterized constructor{this(1);// Calling of constructorSystem.out.println("0-arg-cons");}Example(inta)// Parameterized constructor{System.out.println("1-arg-cons");}}publicstaticvoidmain(String[]args){Examplee=newExample();}
Java provides access to thesuperclass's constructor through thesuper keyword.
publicclassExample{// Definition of the constructor.publicExample(){this(1);}// Overloading a constructorpublicExample(intinput){data=input;// This is an assignment}// Declaration of instance variable(s).privateintdata;}
// Code somewhere else// Instantiating an object with the above constructorExamplee=newExample(42);
A constructor taking zero number of arguments is called a "no-arguments" or "no-arg" constructor.[12]
As of ES6,JavaScript has direct constructors like many other programming languages. They are written as such
classFooBar{constructor(baz){this.baz=baz}}
This can be instantiated as such
constfoo=newFooBar('7')
The equivalent of this before ES6, was creating a function that instantiates an object as such
functionFooBar(baz){this.baz=baz;}
This is instantiated the same way as above.
InObject Pascal, the constructor is similar to afactory method. The only syntactic difference to regular methods is the keywordconstructor in front of the name (instead ofprocedure orfunction). It can have any name, though the convention is to haveCreate as prefix, such as inCreateWithFormatting. Creating an instance of a class works like calling a static method of a class:TPerson.Create('Peter').
programOopProgram;typeTPerson=classprivateFName:string;publicpropertyName:stringreadFName;constructorCreate(AName:string);end;constructorTPerson.Create(AName:string);beginFName:=AName;end;varPerson:TPerson;beginPerson:=TPerson.Create('Peter');// allocates an instance of TPerson and then calls TPerson.Create with the parameter AName = 'Peter'end.
InOCaml, 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 calledinitializer allows to evaluate an expression immediately after the object has been built.[13]
classpersonfirst_namelast_name=objectvalfull_name=first_name^" "^last_nameinitializerprint_endline("Hello there, I am "^full_name^".")methodget_last_name=last_nameend;;letalonzo=newperson"Alonzo""Church"in(*Hello there, I am Alonzo Church.*)print_endlinealonzo#get_last_name(*Church*)
InPHP version 5 and above, the constructor is a method named__construct() (notice that it's a double underscore), which the keywordnew 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 thenew statement is written, you also need to send the constructor arguments for the parameters.[1]
classPerson{privatestring$name;publicfunction__construct(string$name):void{$this->name=$name;}publicfunctiongetName():string{return$this->name;}}
In PHP, a class is only allowed to declare a maximum of one constructor method. Static methods, factory classes or optional constructor arguments are some ways to facilitate multiple ways to create objects of a PHP class.
InPerl version 5, by default, constructors arefactory methods, that is, methods that create and return the object, concretely meaning create and return a blessed reference. A typical object is a reference to a hash, though rarely references to other types are used too. By convention the only constructor is namednew, though it is allowed to name it otherwise, or to have multiple constructors. For example, a Person class may have a constructor namednew, and a constructornew_from_file which reads a file for Person attributes, andnew_from_person which uses another Person object as a template.
packagePerson;# In Perl constructors are named 'new' by convention.subnew{# Class name is implicitly passed in as 0th argument.my$class=shift;# Default attribute values, if you have any.my%defaults=(foo=>"bar");# Initialize attributes as a combination of default values and arguments passed.my$self={%defaults,@_};# Check for required arguments, class invariant, etc.if(notdefined$self->{first_name}){die"Mandatory attribute missing in Person->new(): first_name";}if(notdefined$self->{last_name}){die"Mandatory attribute missing in Person->new(): last_name";}if(defined$self->{age}and$self->{age}<18){die"Invalid attribute value in Person->new(): age < 18";}# Perl makes an object belong to a class by 'bless'.bless$self,$class;return$self;}1;
In theMoose object system for Perl, most of this boilerplate can be omitted, a defaultnew is created, attributes can be specified, and whether they can be set, reset, or are required. In addition, any extra constructor functionality can be included in aBUILD method which the Moose generated constructor will call, after it has checked the arguments. ABUILDARGS method can be specified to handle constructor arguments not in hashref / key => value form.
packagePerson;# enable Moose-style object constructionuseMoose;# first name ( a string) can only be set at construction time ('ro')hasfirst_name=>(is=>'ro',isa=>'Str',required=>1);# last name ( a string) can only be set at construction time ('ro')haslast_name=>(is=>'ro',isa=>'Str',required=>1);# age (Integer) can be modified after construction ('rw'), and is not required# to be passed to be constructor. Also creates a 'has_age' method which returns# true if age has been sethasage=>(is=>'rw',isa=>'Int',predicate=>'has_age');# Check custom requirementssubBUILD{my$self=shift;if($self->has_age&&$self->age<18){# no under 18sdie"No under-18 Persons";}}1;
In both cases the Person class is instiated like this:
usePerson;my$p=Person->new(first_name=>'Sam',last_name=>'Ashe',age=>42);
InPython, constructors are defined by one or both of__new__ and__init__ methods. A new instance is created by calling the class as if it were a function, which calls the__new__ and__init__ methods. If a constructor method is not defined in the class, the next one found in the class's Method Resolution Order will be called.[14]
In the typical case, only the__init__ method need be defined. (The most common exception is for immutable objects.)
>>>classExampleClass:...def__new__(cls,value):...print("Creating new instance...")...# Call the superclass constructor to create the instance....instance=super(ExampleClass,cls).__new__(cls)...returninstance...def__init__(self,value):...print("Initialising instance...")...self.payload=value>>>exampleInstance=ExampleClass(42)Creating new instance...Initialising instance...>>>print(exampleInstance.payload)42
Classes normally act asfactories 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.[14]
InRaku, even more boilerplate can be omitted, given that a defaultnew 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 aBUILD method which will get called to allow for custom initialization. ATWEAK method can be specified to post-process any attributes already (implicitly) initialized.
classPerson {hasStr$.first-nameisrequired;# First name (a string) can only be set at# construction time (the . means "public").hasStr$.last-nameisrequired;# Last name (a string) can only be set at# construction time (a ! would mean "private").hasInt$.ageisrw;# 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.methodfull-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 requirementsmethodTWEAK {ifself!has-age &&$!age <18 {# No under 18die"No person under 18"; } }}
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, thenamed parameters can be specified using the colon-pair syntax in Perl 6:
my$p0 =Person.new( :first-name<Sam>, :last-name<Ashe>, :age(42) );my$p1 =Person.new( :first-name<Grace>, :last-name<Hopper> );
And should you have set up variables with names identical to the named parameters, you can use a shortcut that will use thename 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 );
InRuby, constructors are created by defining a method calledinitialize. This method is executed to initialize each new instance.
irb(main):001:0>classExampleClassirb(main):002:1>definitializeirb(main):003:2>puts"Hello there"irb(main):004:2>endirb(main):005:1>end=> nilirb(main):006:0>ExampleClass.newHello there=> #<ExampleClass:0x007fb3f4299118>
InVisual Basic .NET, constructors use a method declaration with the name "New".
ClassFoobarPrivatestrDataAsString' ConstructorPublicSubNew(ByValsomeParamAsString)strData=someParamEndSubEndClass
' code somewhere else' instantiating an object with the above constructorDimfooAsNewFoobar(".NET")