1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

///// initialize struct instance /////
typedef struct Point {
  double x, y;
} Point_t;

// declare and initialize
Point_t p;
p.x = 1; p.y = 2;
// bracket initialization
Point_t q = { 1, 2 };
Point_t r = { .x = 1, .y = 2};
// initialize on heap
Point_t *s = (Point_t *)malloc(sizeof(Point_t));
s->x = 1; s->y = 2;

///// initialize array /////
Point_t arr[10]; // declare without initialization
Point_t arr2[5] = { {.x = 1, .y = 2}, {.x = 3, .y = 4} }; // initializer, here the third value is uninitialized
Point_t arr3[] = { {.x = 1, .y = 2} }; // the size of array is inferred to be 1
Point_t arr4[5] = { {.x = 1, .y = 2}, [1 ... 4] = {.x = 3, .y = 4} }; // range initialize 2nd ~ 5th item
int arr_2d[3][3] = {1,2,3,4,5,6,7,8,9}; // you can even initialize 2D array with bracket initialization
int arr2_2d[3][3] = {{1,2,3},{4,5,6},{7,8,9}};

// declare the array on heap with 5 items
Point_t *arr5 = (Point_t *)malloc(5 * sizeof(Point_t));
free(arr5);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

///// initialize class instance /////
class Point {
public:
  double x, y;
  // C++ will create default constructors with no args, field args and initializer list
};

// declare and initialize
Point p;
p.x = 1; p.y = 2;
// direct initialize
Point q(1, 2);
// initializer
Point r { 1, 2 }; // list initializer (C++11)
Point s { .x = 1, .y = 2 }; // aggregate initializer (C++20)
// initialize on heap
Point *t = new Point(1, 2);
Point *u = new Point{1, 2};

///// initialize array /////
// C++ supports all initialization method from C, but you might need C++11/20

// declare the array on heap with 5 items
Point* arr = new Point[5]{ {1, 2} }; // all initializer syntax can be used here
delele[] arr;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

///// initialize class instance /////
class Point {
  public double X { get; set; }
  public double Y { get; set; }
  Point() {}
  Point(double x, double y) { X = x; Y = y; }
}

// declare and initialize
Point p = new Point();
p.x = 1; p.y = 2;
// constructor
Point q = new Point(1, 2);
Point r = new Point { X = 1, Y = 2 };
// anonymous type
var s = new { X = 1, Y = 2};

///// initialize array /////
Point[] arr = new Point[3]; // new array with null values (or default value for struct type)
Point[] arr2 = new Point[3] { p, q, r };
Point[,] arr2d = new Point[2, 2] { {p, q}, {r, r} }; // initialize 2d array

var numbers = new Dictionary<int, string> // initialize object with indexers
{
    [7] = "seven",
    [9] = "nine",
    [13] = "thirteen"
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

///// initialize struct instance /////
struct Point {
  x: f64,
  y: f64
}

let p = Point { x: 1., y: 2. }; // rust don't automatically cast the type
let q = Point { x: 2., ..p }; // partial copy from another instance
let x = 2.;
let r = Point { x, y: 2. }; // using the variable with the same name in scope

///// initialize array /////
let _: [u8; 3] = [1, 2, 3];
let arr: [Point; 3] = [ p, q, r ];

1

const int SOME_CONSTANT = 1;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// constexpr is used for compile time constant
constexpr int SOME_CONSTANT = 1;
constexpr int constexpr_func() { return 1; }

// const can be used to describe class members
class Coords
{
    void shift (const Coords &offset);
    double sum() const { return _x + _y; };

    const double _x, _y;
    Coords(double x, double y) : _x(x), _y(y) {} // const field must be initialized using initializer list
}

// const variables are only able to call const member function
const Coords coord;
coord.sum();
// coord.shift() is illegal here

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// `const` is used for compile time constant
const int SOME_CONSTANT = 1;

class SomeType
{
  public const int const_field = 1; // the value still need to be defined in compile time
  private readonly string const_field2;
  SomeType(string str_in) { const_field2 = str_in; } // readonly field must be initialized in declaration or constructor
}

// since C# 7.2, readonly can be used to declare immutable type
public readonly struct Coords
{
  public Coords(double x, double y) { X = x; Y = y; }

  public double X { get; init; }
  public double Y { get; init; }

  public readonly double Sum() { return X + Y; } // C# 8.0
}

// alternatively readonly can be applied to properties individually
public struct Coords
{
  public Coords(double x, double y) { _x = x; Y = y; }

  private int _x;
  public double X { readonly get => _x; }
  public readonly double Y { get; init; } // C# 9.0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// use `const` for compile time constant
const SOME_CONSTANT: u32 = 1;

let some_constant = 1; // immutable by default
let some_constant = 2; // this will shadow the previous definition

struct Coords { x: f64, y: f64}
impl Coords {
  fn sum(&self) -> f64 { // the instance is also immutable in methods
    self.x * self.y
  }
  fn offset(&mut self, Coords offset) {
    self.x += offset.x;
    self.y += offset.y;
  }
}

1
2

// variables defined in global are global variables
int counter = 0;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

int counter = 0; // this is a global variable

namespace sub {
  int sub_counter = 0; // this is a global variable, but here "global" is a namespace
  static int counter2 = 0; // rarely used, static here means the variable is local to this compliation unit (this source file)
}

class Player {
  int id = 0;

  // static members of a class
  static int counter = 0;
  static Player create_player() {
    return Player { counter++ };
  }

  // static variable can be inside a function
  static Player create_player2() {
    static int counter2 = 0;
    return Player { counter2++ };
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// there is no global variable, you have to tie the variable to a class.
// But note that const variable can be in global scope, and you don't need to declare it as static
static class Utility
{
  static int counter = 0;

  static readonly int some_constant;
  static Utility() {
    some_constant = 1; // the static constructor can be used to assign value to static readonly object
  }
}

class Player
{
  Player(int id) {}

  private static int counter = 0;
  public static Player create_player() {
    return new Player(counter++);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// you need static keyword to declare global/static variables
static some_constant: i32 = 1;
static mut counter: i32 = 0;

struct Player(i32);

fn create_player() -> Player {
  println!("{}", some_constant); // read constant static variable is safe

  unsafe { // read and write to mutable static variable is unsafe in rust
    counter += 1;
  }
  return Player(counter)
}

1
2
3
4
5
6
7
8

// normal function
int add(int a, int b) {
  return a + b;
}

// function pointers
int (*fn_ptr) (int, int) = &add;
int (const *fn_cptr) (int, int) = &add;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// normal function
int add(int a, int b) {
  return a + b;
}

// function pointers are also supported in C++
// note that the syntax can be much more complex in C++ than in C
int (*fn_ptr) (int, int) = &add;
int (const *fn_cptr) (int, int) = &add;

// std::function is a safer pointer implementation
// (since C++11, you can use boost::function before C++11)
std::function<int (int, int)> func = add;

// lambda function (which is a closure, since C++11)
std::string prefix = "INFO:";
auto log_handler = [&prefix](std::string x) { std::cout << prefix << x; }
std::function<void (std::string)> func2 = log_handler;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// normal function
int add(int a, int b) {
  return a + b;
}

// delegates are function pointer types in C#
public delegate int AddFunc (int a, int b);
AddFunc func = add;
System.Func<int, int, int> func2 = add; // there are also predefined delegates

// C# also provides Event to handle a chain of functions
// (usually used in GUI applications)
public event AddFunc addEvents;
addEvents += func;

// lambda function in C#, note that the types of parameter and return value
//     are decided by the function type signature
string prefix = "INFO:";
System.Func<string, void> log_handler = (x) => Console.WriteLine(prefix + x);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// normal function
fn add(a: i32, b: i32) -> i32 {
  a + b
}

// function pointer has type `fn`
let func: fn(i32, i32) -> i32 = add;

// define and return closure
// You need to wrap closure with Box in order to return it since the size of closure is unknown for compiler
fn closure() -> Box<dyn Fn(i32) -> i32> {
  let some_value = 2;
  let increase: Fn(i32) -> i32 = |x| some_value + x;
  Box::new(increase)
}
let func_boxed = closure();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// before C++20
#include <future>
#include <thread>

bool io_task () {
  std::cout << "fake io processing\n";
  std::this_thread::sleep_for(std::chrono::seconds(1));
  return true;
}

std::future<bool> fut = std::async(io_task); // start a thread to run the task
bool result = fut.get(); // wait for the result

// co_await has been introduced in C++20, but it's still not ready to use

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

using System.Threading.Tasks;

async Task io_task() { // the return type for async functions is void / Task / Task<T>. For WinRT, you'll need IAsyncOperation in place of Task
  Console.WriteLine("fake io processing...");
  await Task.Delay(1000);
}
io_task().Wait(); // start the coroutine and wait for its completion, very intuitive

async void io_task_detached() {
  await io_task();
}
io_task_detached(); // start the coroutine and don't wait for it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

use std::time::Duration;
use async_std::task;

// async function has normal return types
async fn io_task() {
  println!("fake io processing...")
  task::sleep(Duration::from_secs(1)).await;
}

// async block returns a Future<T> object
task::block_on(async {io_task()})