Constructors & Destructors

C

// Not Available

C++

// 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
	// ------------------------------------
};

C#

class MyClass
{
	public MyClass()
	{
		// Default Constructor
	}

	public MyClass(int value)
	{
		// Constructor With Parameters
	}

	~MyClass()
	{
		// Finalizer
	}
}

Java

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
	}
}

Rust

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);

Go

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
}

Javascript

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
	}
}

Typescript

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
	}
}

Python

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