Wikipedia

Constructor (object-oriented programming): Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
Filled in 6 bare reference(s) with reFill 2
 
(16 intermediate revisions by 3 users not shown)
Line 13:
 
<syntaxhighlight lang="cpp">
class ExamplePoint {
private:
public:
Example() int x;
int y;
Example(int a, int b); // Parameterized constructor.
public:
 
Point() = default;
private:
Point(int x, int x_;y):
x{x}, y{y} {} // Parameterized constructor
int y_;
};
 
Example::Example() = default;
 
Example::Example(int x, int y) : x_(x), y_(y) {}
</syntaxhighlight>
 
<syntaxhighlight lang="cpp">
ExamplePoint ep = ExamplePoint(0, 50); // Explicit call.
ExamplePoint e2p2(0, 50); // Implicit call.
</syntaxhighlight>
 
Line 37 ⟶ 33:
 
<syntaxhighlight lang="cpp">
class Point {
#include <iostream>
private:
 
int x;
class Student {
int y;
public:
public:
Student(int a = 0, int b = 0); // Default constructor.
Point(int x = 0, int y = 0); // Default constructor.
 
int a;
int b;
};
</syntaxhighlight>
Line 50 ⟶ 44:
=== Copy constructors ===
{{see also|Copy constructor (C++)}}
Like C++, Java also supports "Copy ConstructorConstructors". 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.
 
Line 61 ⟶ 55:
== Syntax ==
* [[Java (programming language)|Java]], [[C++]], [[C Sharp (programming language)|C#]], [[ActionScript]], {{nowrap|[[PHP]] 4}}, and [[MATLAB]] have a naming convention in which constructors have the same name as the class with which they are associated.
* In [[Rust (programming language)|Rust]], the convention for the "constructor" is to name it <code>new</code>.
* In PHP 5, a recommended name for a constructor is <code>__construct</code>. For backwards compatibility, a method with the same name as the class will be called if <code>__construct</code> method can not be found. Since PHP 5.3.3, this works only for non-namespaced classes.<ref name="php5cpnstructor">[http://www.php.net/manual/en/language.oop5.decon.php Constructors and Destructors], from PHP online documentation</ref>
* In PHP 7, you should always name the constructor as <code>__construct</code>. Methods with the same name as the class will trigger an E_DEPRECATED level error.<ref name="php5cpnstructor"/>
Line 71 ⟶ 66:
 
== Memory organization ==
In Java, C#, and VB .NET, the constructor creates reference type objects on the heap, whereas primitive types (such as <code>int</code>, <code>double</code>, etc.) are stored on the [[Stack-based memory allocation|stack]] (though some languages allow for manually allocating objects on the stack through a <code>stackalloc</code> modifier). VB .NET and C# also allow the use of the <code>new</code> 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 Java, C#, and VB .NET, the constructor creates reference type objects in a special memory structure called the
"[[heap (data structure)|heap]]". Value types (such as int, double, etc.) are created in a sequential structure called the "[[stack (abstract data type)|stack]]".
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 C++, objects are created on the stack when the constructor is invoked without the <code>new</code> operator, and created on the heap when the constructor is invoked with the <code>new</code> 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 ''<code>delete''</code> operator. By using the "[[Resource Acquisition is Initialization]]" (RAII) idiom, resource management can be greatly simplified.
 
== Language details ==<!-- see also Category:Programming language comparisons -->
Line 83 ⟶ 76:
In [[C++]], the name of the constructor is the name of the class. It returns nothing. It can have parameters like any [[Method (computer programming)|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 (computer science)|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 you have ''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).<ref>https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order Constructor</ref> 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.
Line 90 ⟶ 83:
 
<syntaxhighlight lang="cpp">
import std;
class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
 
class PolarPoint {
private:
private:
double x_;
double y_x;
double y;
public:
PolarPoint(double r = 1.0, double theta = 0.0): // Constructor, parameters with default values.
x{r * std::cos(theta)}, y{r * std::sin(theta)} /* <- Initializer list */ {
std::println("Point: x = {}, y = {}", x, y); // Constructor body
}
};
</syntaxhighlight>
Example invocations:
<syntaxhighlight lang="cpp">
PolarPoint a;
Foobar a,
PolarPoint b(3),;
PolarPoint c(5, M_PIstd::numbers::pi / 4);
</syntaxhighlight>
 
Line 182 ⟶ 174:
 
'''Cheese.cfc'''
<syntaxhighlight lang="javascriptcfc">
component {
// properties
Line 196 ⟶ 188:
 
Create instance of a cheese.
<syntaxhighlight lang="javascriptcfc">
myCheese = new Cheese( 'Cheddar' );
</syntaxhighlight>
Line 202 ⟶ 194:
Since ColdFusion 10,<ref>[https://wikidocs.adobe.com/wiki/display/coldfusionen/cfcomponent CFComponent]</ref> CFML has also supported specifying the name of the constructor method:
 
<syntaxhighlight lang="javascriptcfc">
component initmethod="Cheese" {
// properties
Line 325 ⟶ 317:
 
<syntaxhighlight lang="java">
class ExampleX {
public X() { // Non-parameterized constructor
{
Example() // Non-parameterized constructor
{
this(1); // Calling of constructor
System.out.println("0-arg-consCalling default constructor");
}
 
Example(int a) // Parameterized constructor
public X(int a) { // Parameterized constructor
{
System.out.println("1-arg-consCalling parameterized constructor");
}
}
 
public static void main(String[] args)
public class Example {
{
public static void main(String[] args) {
Example e = new Example();
X x = new X();
}
}
</syntaxhighlight>
Line 346 ⟶ 338:
 
<syntaxhighlight lang="java">
public class ExampleX {
// Declaration of instance variable(s).
{
private int data;
 
// Definition of the constructor.
public ExampleX() {
{
this(1);
}
 
// Overloading a constructor
public ExampleX(int input) {
{
data = input; // This is an assignment
}
}
 
class Y extends X {
// Declaration of instance variable(s).
private int datadata2;
 
public Y() {
super();
data2 = 1;
}
 
public Y(int input1, int input2) {
super(input1);
data2 = input2
}
}
</syntaxhighlight>
 
public class Example {
<syntaxhighlight lang="java">
public static void main(String[] args) {
// Code somewhere else
Y y = new Y(42, 43);
// Instantiating an object with the above constructor
}
Example e = new Example(42);
}
</syntaxhighlight>
 
A constructor taking zero number of arguments is called a "no-arguments" or "no-arg" constructor.<ref>{{cite web|url=http://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html|title= Providing Constructors for Your Classes |publisher=Oracle Corporation|date=2013|access-date=2013-12-20}}</ref>
 
=== JavaScript/TypeScript ===
As of ES6, [[JavaScript]] has direct constructors like many other programming languages. They are written as such
 
<syntaxhighlight lang="javascript">
class FooBar {
constructor(baz) {
this.baz = baz;
}
}
</syntaxhighlight>
Line 387 ⟶ 390:
 
<syntaxhighlight lang="javascript">
const foo = new FooBar('7');
</syntaxhighlight>
 
Line 394 ⟶ 397:
<syntaxhighlight lang="javascript">
function FooBar (baz) {
this.baz = baz;
}
</syntaxhighlight>
 
This is instantiated the same way as above.
 
The [[TypeScript]] equivalent of this would be:
<syntaxhighlight lang="typescript">
class FooBar {
baz: string;
 
constructor(baz: string) {
this.baz = baz;
}
}
 
const foo: FooBar = new FooBar('7');
</syntaxhighlight>
 
=== Object Pascal ===
Line 540 ⟶ 556:
In the typical case, only the <code>__init__</code> method need be defined. (The most common exception is for immutable objects.)
 
<syntaxhighlight lang="pyconpython">
>>> 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):
def __init__(self, value: int) -> None:
... print("Initialising instance...")
print("Initialising instance...")
... self.payload = value
self.payload: int = value
>>> exampleInstance = ExampleClass(42)
 
if __name__ == "__main__":
exampleInstance: ExampleClass = ExampleClass(42)
print(exampleInstance.payload)
</syntaxhighlight>
 
This prints:
<pre>
Creating new instance...
Initialising instance...
>>> print(exampleInstance.payload)
42
</pre>
</syntaxhighlight>
 
Classes normally act as [[Factory (object-oriented programming)|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 <code>__new__</code> method is permitted to return something other than an instance of the class for specialised purposes. In that case, the <code>__init__</code> is not invoked.<ref name="auto"/>
Line 623 ⟶ 646:
Hello there
=> #<ExampleClass:0x007fb3f4299118>
</syntaxhighlight>
 
=== Rust ===
[[Rust (programming language)|Rust]] does not have constructors in the sense of object-oriented programming, but often structs have a <code>new()</code> method that essentially acts as a constructor. The return type is usually indicated as <code>Self</code>.
 
<syntaxhighlight lang="rust">
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);
}
</syntaxhighlight>
 
Retrieved from "https://en.wikipedia.org/wiki/Constructor_(object-oriented_programming)"