Constructors & Destructors
- C
- C++
- C#
- Java
- Rust
- Go
- Javascript
- Typescript
- Python
// Not Available
// Header File (MyClass.h or MyClass.hpp)
#pragma once
class MyClass
{
// Simplified Example
// ------------------------------------
// Constructor
// ------------------------------------
// The constructor has the same name as the class
// Can be omitted if you have no code to put here.
MyClass();
// You can have more than one
MyClass(int value);
MyClass(int value, float otherValue);
MyClass(char letter);
//and so on
// You can add the "explicit" keyword to avoid implicit conversion
explicit MyClass(int value);
explicit MyClass(int value, float otherValue);
explicit MyClass(char letter);
// You can also "delete" a specific constructor to remove its use
MyClass() = delete; // this constructor wont be available
};
// Header File (MyClass.h or MyClass.hpp)
#pragma once
class MyClass
{
// Simplified Example
// ------------------------------------
// Member Initializer / Member Initializer Lists
// ------------------------------------
};
// Header File (MyClass.h or MyClass.hpp)
#pragma once
class MyClass
{
// Simplified Example
// ------------------------------------
// Copy Constructor
// ------------------------------------
};
// Header File (MyClass.h or MyClass.hpp)
#pragma once
class MyClass
{
// Simplified Example
// ------------------------------------
// Move Constructor
// ------------------------------------
};
// Header File (MyClass.h or MyClass.hpp)
#pragma once
class MyClass
{
// Simplified Example
// ------------------------------------
// Desconstructor
// ------------------------------------
};
class MyClass
{
public MyClass()
{
// Default Constructor
}
public MyClass(int value)
{
// Constructor With Parameters
}
~MyClass()
{
// Finalizer
}
}
class MyClass {
public MyClass() {
// Default Constructor
}
public MyClass(int value) {
// Constructor With Parameters
}
}
// Destructors are Not Available.
// Use try-with-resources and AutoCloseable for deterministic cleanup.
class MyResource implements AutoCloseable {
@Override
public void close() {
// cleanup
}
}
struct MyStruct {
value: i32,
}
impl MyStruct {
fn new(value: i32) -> Self {
Self { value }
}
}
impl Drop for MyStruct {
fn drop(&mut self) {
// cleanup
}
}
let value = MyStruct::new(10);
type MyStruct struct {
Value int
}
// Go has no constructor syntax.
// Use factory functions by convention.
func NewMyStruct(value int) MyStruct {
return MyStruct{Value: value}
}
// Destructors are Not Available.
// Use explicit Close/Cleanup methods when needed.
func (value MyStruct) Close() error {
// cleanup
return nil
}
class MyClass {
constructor(value) {
this.value = value;
}
}
const myClass = new MyClass(10);
// Destructors are Not Available.
// Use explicit cleanup methods when needed.
class Resource {
close() {
// cleanup
}
}
class MyClass {
public constructor(private readonly value: number) {
// ...
}
}
const myClass = new MyClass(10);
// Destructors are Not Available.
// Use explicit cleanup methods when needed.
class Resource {
public close(): void {
// cleanup
}
}
class MyClass:
def __init__(self, value):
self.value = value
def __del__(self):
# Finalizer. Avoid relying on it for important cleanup.
pass
my_class = MyClass(10)
# Prefer context managers for deterministic cleanup.
class Resource:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
# cleanup
pass