Basic Template

C

// Not Available
// C does not have Classes
// But there are some advanced workarounds with structs

C++

// Header File (MyClass.h or MyClass.hpp) (Only declaration. No Implementation)

// You could also use the "pragma"
#ifndef MY_CLASS_H
#define MY_CLASS_H

class MyClass
{
	float some_random_variable; // private by default (if not inside a access specifiers)

private: // Private access specifiers
	// ------------------------------------
	// Private Properties / Fields
	// ------------------------------------
	float my_private_property;

	// ------------------------------------
	// Private Methods
	// ------------------------------------

	// Since its a private method, It can only be called inside this class
	void myPrivateMethod (float someVariable);

protected: // Protected access specifiers
// In this example I wont use "protected"
// If not in use, you can ommit an access specifiers

public: // Public access specifiers
	// ------------------------------------
	// Public Properties / Fields
	// ------------------------------------
	float my_public_property;

	// ------------------------------------
	// Constructor
	// ------------------------------------

	// The constructor has the same name as the class
	// Can be omited if you have no code to put here.
	MyClass();

	// ------------------------------------
	// Accessors (getter/setter)
	// ------------------------------------

	// Calling "getMyPrivateProperty" Ex.: myClassInstance.getMyPrivateProperty();
	float getMyPrivateProperty();

	// Calling "setMyPrivateProperty" Ex.: myClassInstance.setMyPrivateProperty(10.2);
	void setMyPrivateProperty(float value);

	// ------------------------------------
	// Public Methods
	// ------------------------------------

	// Calling "myPublicMethod" Ex.: myClassInstance.myPublicMethod(20.0);
	void myPublicMethod (float someVariable);

};	// Dont forgete the ; (semicolon) here

#endif // MY_CLASS_H

// Code file (MyClass.cpp)

#include "MyClass.h"

// We dont need to wrap all methods inside class {} for the Implementation
// But we need to prefix them with the class name and ::

// ------------------------------------
// Constructor
// ------------------------------------
MyClass::MyClass()
{
	// ...
}

// ------------------------------------
// Private Methods
// ------------------------------------
void MyClass::myPrivateMethod (float someVariable)
{
	//...
}

// ------------------------------------
// Accessors (getter/setter)
// ------------------------------------

// Calling "getMyPrivateProperty" Ex.: myClassInstance.getMyPrivateProperty();
float MyClass::getMyPrivateProperty()
{
	return this->my_private_property; // "this->" instead of "this."
}

// Calling "setMyPrivateProperty" Ex.: myClassInstance.setMyPrivateProperty(10.2);
void MyClass::setMyPrivateProperty(float value)
{
	this->my_private_property = value; // "this->" instead of "this."
}

// ------------------------------------
// Public Methods
// ------------------------------------

// Calling "myPublicMethod" Ex.: myClassInstance.myPublicMethod(20.0);
void MyClass::myPublicMethod (float someVariable)
{
	//...
}

// Passing and returning by const reference
// Prefer this for non-fundamental types when the function should not mutate the value.

class MyClass
{
private:
	std::string my_private_property;

public:
	std::string const &getMyPrivateProperty() const
	{
		return this->my_private_property;
	}

	void setMyPrivateProperty(std::string const &value)
	{
		this->my_private_property = value;
	}
};

// In some cases, like building a library, you might have everything inside the header file

// Everything Inside a Header File (MyClass.h or MyClass.hpp)

#pragma once // When using pragma, no need to use anything at the end (like #endif)

class MyClass
{
private:
	float my_private_property;

	void myPrivateMethod (float someVariable);

public:
	float my_public_property;

	MyClass();

	float getMyPrivateProperty();
	void setMyPrivateProperty(float value);

	void myPublicMethod (float someVariable);

};	// Dont forgete the ; (semicolon) here


// We dont need to wrap all methods inside class {} for the Implementation
// But we need to prefix them with the class name and ::
MyClass::MyClass()
{
	// ...
}

void MyClass::myPrivateMethod (float someVariable)
{
	//...
}

float MyClass::getMyPrivateProperty()
{
	return this->my_private_property;
}

void MyClass::setMyPrivateProperty(float value)
{
	this->my_private_property = value;
}

void MyClass::myPublicMethod (float someVariable)
{
	//...
}

// ------------------------------------
// Instantiating the class
// ------------------------------------

// Option 1 - No need to free the memory
MyClass myClassInstanceName;
MyClass myClassInstanceName{};
// OBS: Members will be accessible via "." operator
// Ex.: myClassInstanceName.MyMethod();


// Option 2 - Smart Pointer - No need to free the memory
#include <memory>

// OBS: Using Smart Pointers, Members will be accessible via "->" operator
// Ex.: myClassInstanceName->MyMethod();

// Smart Pointer - std::unique_ptr
// Dynamically allocated object that is not shared by multiple objects
std::unique_ptr<MyClass> myClassInstanceName {std::make_unique<MyClass>()}; // Since C++ 14 (std::make_unique)

auto myClassInstanceName {std::make_unique<MyClass>()};
auto myClassInstanceName = std::make_unique<MyClass>(); // Same as Above

std::unique_ptr<MyClass> myClassInstanceName {}; // Start as nullptr
std::unique_ptr<MyClass> myClassInstanceName; // Start as nullptr
myClassInstanceName = std::make_unique<MyClass>();

// Before C++ 14
std::unique_ptr<MyClass> myClassInstanceName (new MyClass());
std::unique_ptr<MyClass> myClassInstanceName {new MyClass{}}; // Using { }


// Smart Pointer - std::shared_ptr
// Dynamically allocated object that is shared by multiple objects
std::shared_ptr<MyClass> myClassInstanceName {std::make_shared<MyClass>()}; // Since C++ 14 (std::make_unique)

auto myClassInstanceName {std::make_shared<MyClass>()};
auto myClassInstanceName = std::make_shared<MyClass>(); // Same as Above

std::shared_ptr<MyClass> myClassInstanceName {}; // Start as nullptr
std::shared_ptr<MyClass> myClassInstanceName; // Start as nullptr
myClassInstanceName = std::make_shared<MyClass>();

// More about Pointers in the "Pointer & Reference" Section


// Option 3 - Legacy (Avoid)
MyClass* myClassInstanceName = new MyClass();
// ...
delete(myClassInstanceName); // You have to delete (free the memory) after you're done

More Info:

• https://stackoverflow.com/questions/8020113/c-include-guards/8020211#8020211
• https://www.learncpp.com/cpp-tutorial/82-classes-and-class-members/
• https://www.learncpp.com/cpp-tutorial/89-class-code-and-header-files/
• https://www.learncpp.com/cpp-tutorial/8-8-the-hidden-this-pointer/
• https://docs.microsoft.com/en-us/cpp/cpp/header-files-cpp?view=vs-2019
• http://www.cplusplus.com/doc/tutorial/classes/
• https://www.learncpp.com/cpp-tutorial/69-dynamic-memory-allocation-with-new-and-delete/
• https://stackoverflow.com/questions/10836591/class-members-and-explicit-stack-heap-allocation
• https://en.cppreference.com/w/cpp/memory/unique_ptr
• https://en.cppreference.com/w/cpp/memory/shared_ptr

C#

public class MyClass
{
	// ------------------------------------
	// Fields
	// ------------------------------------
	public int myPublicField; // public field (Generally not recommended.)
	protected int myProtectedField; // Fields should be protected or private for internal use
	private int myPrivateField; // Fields should be camelCase

	// ------------------------------------
	// Properties (Fields with Accessors)
	// ------------------------------------
	public int MyPublicProperty { get; set; } // Properties should be PascalCase
	protected int MyProtectedProperty { set; }
	private int MyPrivateProperty { get; }

	// Calling get "MyPublicProperty" Ex.: myClassInstance.MyPublicProperty;
	// Calling set "MyPublicProperty" Ex.: myClassInstance.MyPublicProperty = 10;

	// ------------------------------------
	// Constructor
	// ------------------------------------

	// The constructor has the same name as the class
	// Can be omited if you have no code to put here.
	public MyClass()
	{
		// ...
	}

	// ------------------------------------
	// Accessors (getter/setter)
	// ------------------------------------

	// You dont need a dedicated getter/setter if
	// you declared either/both { get; set; }

	// But you can add custom rules to your get/sets

	// Example
	private string name; // field definition
	public string Name   // property definition
	{
		// You dont need both get and set
		get
		{
			return name;
		}
		set // set has implicit "value" parameter
		{
			if (value.Trim().Length < 3 )
			{
				throw new MyCustomException($"{nameof(value)} must have more than 3 characters.");
			}

			name = value;
		}
	}
	// Calling get "Name" Ex.: myClassInstance.Name;
	// Calling set "Name" Ex.: myClassInstance.Name = "hello";

	// ------------------------------------
	// Methods
	// ------------------------------------

	// Calling "myMethod" Ex.: myClassInstance.myMethod(20);
	public void myMethod (int someVariable)
	{
		//...
	}
}

// ------------------------------------
// Instantiating the class
// ------------------------------------

MyClass myClassInstanceName = new MyClass();

More Info:

• https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties
• https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/using-properties

Java

public class MyClass
{
	// ------------------------------------
	// Properties / Fields
	// ------------------------------------
	public int myPublicProperty; // Public by default
	private int myPrivateProperty;
	protected int myProtectedProperty;

	// ------------------------------------
	// Constructor
	// ------------------------------------

	// The constructor has the same name as the class
	// Can be omited if you have no code to put here.
	public MyClass() // Public by default
	{
		// ...
	}

	// ------------------------------------
	// Accessors (getter/setter)
	// ------------------------------------

	// Calling "getMyProperty" Ex.: myClassInstance.getMyProperty();
	public int getMyProperty()
	{
		return this.myPrivateProperty;
	}

	// Calling "setMyProperty" Ex.: myClassInstance.setMyProperty(10);
	public void setMyProperty(int value)
	{
		this.myPrivateProperty = value;
	}

	// ------------------------------------
	// Methods
	// ------------------------------------

	// Calling "myMethod" Ex.: myClassInstance.myMethod(20);
	public void myMethod (int someVariable)
	{
		//...
	}
}

// ------------------------------------
// Instantiating the class
// ------------------------------------

MyClass myClassInstanceName = new MyClass();

Rust

struct MyClass {
	my_public_property: f32,
	my_private_property: f32,
}

impl MyClass {
	fn new(value: f32) -> Self {
		Self {
			my_public_property: value,
			my_private_property: value,
		}
	}

	fn get_my_private_property(&self) -> f32 {
		self.my_private_property
	}

	fn set_my_private_property(&mut self, value: f32) {
		self.my_private_property = value;
	}
}

let mut my_class = MyClass::new(10.0);
my_class.set_my_private_property(20.0);

Go

type MyClass struct {
	MyPublicProperty  float64
	myPrivateProperty float64
}

func NewMyClass(value float64) MyClass {
	return MyClass{
		MyPublicProperty:  value,
		myPrivateProperty: value,
	}
}

func (value MyClass) GetMyPrivateProperty() float64 {
	return value.myPrivateProperty
}

func (value *MyClass) SetMyPrivateProperty(newValue float64) {
	value.myPrivateProperty = newValue
}

myClass := NewMyClass(10.0)
myClass.SetMyPrivateProperty(20.0)

Javascript

class MyClass {
	// ------------------------------------
	// Properties / Fields
	// ------------------------------------

	myPublicField = 0;
	#myPrivateField = 10;
	#mySecondPrivateField;

	// Public and Private declaration Syntax are new in Javascript
	/* Since:
		Babel 7.0+
		Node 12
		Public fields are enabled by default in Chrome 72 / V8 7.2
		Private fields are enabled by default in Chrome 74 / V8 7.4
		Public instance fields are enabled by default in Firefox 69
		Public static fields are enabled in Firefox Nightly 75 as of February 22, 2020
		Public instance fields are shipped behind a flag in Safari Technology Preview 101
		TypeScript 3.8
	*/

	// In older code, you will find public "declaration" inside the constructor or a function
	// The field would start to "exist" after its first declarion

	// ------------------------------------
	// Constructor
	// ------------------------------------
	constructor()
	{
		// As stated above, public and Private declaration Syntax are new in Javascript
		// In older code, you will find public "declaration" inside the constructor or a function.
		// The field would start to "exist" after its first declarion

		this.myAnotherPublicField = "Hello";
	}

	// ------------------------------------
	// Accessors (getter/setter)
	// ------------------------------------

	// Calling get "mySecondPrivateField" Ex.: myClassInstance.mySecondPrivateField;
	get mySecondPrivateField()  {
		return this.#mySecondPrivateField;
	}

	// Calling set "mySecondPrivateField" Ex.: myClassInstance.mySecondPrivateField = "hi";
	set mySecondPrivateField(value) {
		this.#mySecondPrivateField = value;
	}

	// ------------------------------------
	// Methods
	// ------------------------------------

	// Calling "myMethod" Ex.: myClassInstance.myMethod("hello");
	myMethod(someVariable)
	{
		//...
	}
	// IF you can, avoid arrow functions as methods. They won't
	// be in the prototype and can't be called with super().
	// There are some workarounds, Check More Info if you need them.
}

// ------------------------------------
// Instantiating the class
// ------------------------------------

let myClassInstanceName = new MyClass();

More Info:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Class_fields
• https://github.com/tc39/proposal-class-fields
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
• https://medium.com/@charpeni/arrow-functions-in-class-properties-might-not-be-as-great-as-we-think-3b3551c440b1
• https://zendev.com/2018/10/01/javascript-arrow-functions-how-why-when.html
• https://stackoverflow.com/questions/31362292/how-to-use-arrow-functions-public-class-fields-as-class-methods
• https://stackoverflow.com/questions/51400605/javascript-child-class-method-not-overriding-parent-class-method
• https://stackoverflow.com/questions/45881670/should-i-write-methods-as-arrow-functions-in-angulars-class/45882417#45882417
• https://basarat.gitbook.io/typescript/future-javascript/arrow-functions#tip-arrow-functions-and-inheritance

Typescript

class MyClass {
	// ------------------------------------
	// Properties / Fields
	// ------------------------------------
	public myPublicProperty: string; // Public by default
	private myPrivateProperty: string;
	protected myProtectedProperty: string;

	// Javascript private Syntax also available
	#mySecondPrivateProperty: string; // Since Typescript 3.8

	// ------------------------------------
	// Constructor
	// ------------------------------------
	public constructor() // Public by default
	{
		// ...
	}

	// ------------------------------------
	// Accessors (getter/setter)
	// ------------------------------------

	// Calling get "myProperty" Ex.: myClassInstance.myProperty;
	get myProperty() : string {
		return this.myPrivateProperty;
	}

	// Calling set "myProperty" Ex.: myClassInstance.myProperty = "hi";
	set myProperty(value: string) {
		this.myPrivateProperty = value;
	}

	/*
		There are 2 commom patterns for Field & Accessors in Typescript

		- First Pattern: (camelCase Field and PascalCase get/set)

		private myProperty;
		get MyProperty() { ... }
		set MyProperty(value) { ... }

		- Second Pattern: (Underscore in Field name and both in camelCase)
		private _myProperty;
		get myProperty() { ... }
		set myProperty(value) { ... }
	*/

	/*
	TypeScript accessors (getter/setter) require to set the compiler to output
	ECMAScript 5 or higher.

	Accessor with a get and no set property are automatically assumed to be read-only no
	need for manual work. This is helpful when we are generating a .d.ts file from our code.
	*/

	// ------------------------------------
	// Methods
	// ------------------------------------

	// Calling "myMethod" Ex.: myClassInstance.myMethod("hello");
	public myMethod (someVariable: String)
	{
		//...
	}

	// IF you can, avoid arrow functions as methods. They won't
	// be in the prototype and can't be called with super().
	// There are some workarounds, Check More Info if you need them.
}

// ------------------------------------
// Instantiating the class
// ------------------------------------

let myClassInstanceName: MyClass = new MyClass();

More Info:

• https://www.typescriptlang.org/docs/handbook/classes.html
• https://medium.com/@charpeni/arrow-functions-in-class-properties-might-not-be-as-great-as-we-think-3b3551c440b1
• https://zendev.com/2018/10/01/javascript-arrow-functions-how-why-when.html
• https://stackoverflow.com/questions/31362292/how-to-use-arrow-functions-public-class-fields-as-class-methods
• https://stackoverflow.com/questions/51400605/javascript-child-class-method-not-overriding-parent-class-method
• https://stackoverflow.com/questions/45881670/should-i-write-methods-as-arrow-functions-in-angulars-class/45882417#45882417
• https://basarat.gitbook.io/typescript/future-javascript/arrow-functions#tip-arrow-functions-and-inheritance

Python

# Example 1: Direct Access (More Commom)
class MyClass:
	# ------------------------------------
	# Constructor
	# ------------------------------------
	def __init__(self, some_other_param): # All methods starts with "self" param (There are exceptions)
		# You will find "declaration" inside the constructor or a function.
		# The field would start to "exist" after its first declarion

		# Calling Ex.: myClassInstance.my_field
		self.my_field = "Hello" # "Self." is mandatory
		self.my_second_field = some_other_param # "Self." is mandatory

	# ------------------------------------
	# Methods
	# ------------------------------------

	# Calling "myMethod" Ex.: myClassInstance.myMethod("hello");
	def myMethod (self, someVariable):
		#...

# Example 2: Accessors Convention (Direct Access Still possible)
class MyClass:
	# ------------------------------------
	# Constructor
	# ------------------------------------
	def __init__(self, some_other_param): # All methods starts with "self" param (There are exceptions)
		# You will find "declaration" inside the constructor or a function.
		# The field would start to "exist" after its first declarion

		self._my_field = "Hello" # "Self." is mandatory
		self._my_second_field = some_other_param # "Self." is mandatory
		# Underscore at the beggining indicates to be protected or private (convention). Direct Access Still possible
		# _ 1 underscore = protected
		# __ 2 underscore = private

	# ------------------------------------
	# Accessors (getter/setter)
	# ------------------------------------

	# Calling "get_my_field" Ex.: myClassInstance.get_my_field();
	def get_my_field(self):
		return self._my_field # "Self." is mandatory


	# Calling "set_my_field" Ex.: myClassInstance.set_my_field("hi");
	def set_my_field(self, value):
		self._my_field = value; # "Self." is mandatory


	# ------------------------------------
	# Methods
	# ------------------------------------

	# Calling "myMethod" Ex.: myClassInstance.myMethod("hello");
	def myMethod (self, someVariable):
		#...

# Example 3: Property Registration
class MyClass:
	# ------------------------------------
	# Constructor
	# ------------------------------------
	def __init__(self, some_other_param): # All methods starts with "self" param (There are exceptions)
		# You will find "declaration" inside the constructor or a function.
		# The field would start to "exist" after its first declarion

		self._my_field = "Hello" # "Self." is mandatory
		self._my_second_field = some_other_param # "Self." is mandatory
		# Underscore at the beggining indicates to be protected or private (convention). Direct Access Still possible
		# _ 1 underscore = protected
		# __ 2 underscore = private

	# ------------------------------------
	# Accessors (getter/setter)
	# ------------------------------------

	def get_my_field(self):
		return self._my_field # "Self." is mandatory

	def set_my_field(self, value):
		self._my_field = value; # "Self." is mandatory

	# Property Registration
	myField = property(get_my_field, set_my_field)
	# Calling get "get_my_field" Ex.: myClassInstance.myField;
	# Calling set "set_my_field" Ex.: myClassInstance.myField = "hi";

	# ------------------------------------
	# Methods
	# ------------------------------------

	# Calling "myMethod" Ex.: myClassInstance.myMethod("hello");
	def myMethod (self, someVariable):
		#...

# Example 4: Accessors using decorators
class MyClass:
	# ------------------------------------
	# Constructor
	# ------------------------------------
	def __init__(self, some_other_param): # All methods starts with "self" param (There are exceptions)
		# You will find "declaration" inside the constructor or a function.
		# The field would start to "exist" after its first declarion

		self._my_field = "Hello" # "Self." is mandatory
		self._my_second_field = some_other_param # "Self." is mandatory
		# Underscore at the beggining indicates to be protected or private (convention). Direct Access Still possible
		# _ 1 underscore = protected
		# __ 2 underscore = private

	# ------------------------------------
	# Accessors (getter/setter)
	# ------------------------------------

	# getter
	@property
	def my_field(self):
		return self._my_field # "Self." is mandatory

	# setter
	@my_field.setter
	def my_field(self, value):
		self._my_field = value; # "Self." is mandatory

	# Calling get "my_field" Ex.: myClassInstance.myField;
	# Calling set "my_field" Ex.: myClassInstance.myField = "hi";

	# ------------------------------------
	# Methods
	# ------------------------------------

	# Calling "myMethod" Ex.: myClassInstance.myMethod("hello");
	def myMethod (self, someVariable):
		#...

# Example 5: A more complete "basic" example
class MyClass:
	# ------------------------------------
	# Properties / Fields
	# ------------------------------------
	__privateProperty: int = 0 # Type Annotations (PEP 484 / Python 3.6+)
	_protectedProperty: int = 10

	# ------------------------------------
	# Constructor
	# ------------------------------------
	def __init__(self) -> None:
		pass
		# Just an example.
		# If you have nothing to add inside the constructor, you can omit it
		# Or you can use the "pass" keyword inside.
		# Since there are no { } in python, "pass" is the only way to "make it empty"

	# ------------------------------------
	# Accessors (getter/setter)
	# ------------------------------------

	# getter
	@property
	def my_private(self) -> int:
		return self.__privateProperty

	# setter
	@my_private.setter
	def my_private(self, value: int):
		self.__privateProperty = value;


	# Property Registration
	def get_my_protected(self) -> int:
		return self._protectedProperty

	def set_my_protected(self, value: int):
		self._protectedProperty = value;

	myProtected = property(get_my_protected, set_my_protected)

	# ------------------------------------
	# Methods
	# ------------------------------------

	def myMethod (self, someVariable) -> None:
		#...

# ------------------------------------
# Instantiating the class
# ------------------------------------

myClassInstanceName = MyClass()

More Info:

• https://www.geeksforgeeks.org/getter-and-setter-in-python/
• https://www.programiz.com/python-programming/property
• https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html
• https://docs.python.org/3/library/typing.html
• https://realpython.com/python-type-checking/
• https://stackoverflow.com/questions/39817081/typing-any-vs-object