언어별 문법 정리

29 Aug 2019

각 언어별 문법을 정리하고, 특징을 파악한다.

2019년 8월 29일 초안 작성

Loop
Templates, Generics
Iterate through Array
Structs
Classes
Inheritance

C++, Java, Python, Go, TypeScript 순서로 정리한다.

Loop

int sum = 0;
for (int i = 1; i <= 10; i++) {
    sum += i;
}

int sum = 0;
for (int i = 1; i <= 10; i++) {
    sum += i;
}

# Case #1
sum = 0
for i in range(1, 10 + 1):
    sum += i

# Case #2
sum = sum(i for i in range(1, 10 + 1))

var sum int = 0
for i := 1; i <= 10; i++ {
    sum += i
}

let sum: number = 0;
for (let i = 1; i <= 10; i++) {
    sum += i;
}

Templates, Generics

template<class T, class U>
bool are_equal(T a, U b) {
    return (a == b);
}

are_equal(10, 10.0)

public static<T, U> boolean are_equal(T a, U b) {
    return a == b;
}

are_equal(10, 10.0);

# Case #1
def are_equal(a, b):
    return a == b

are_equal(10, 10.0)

# Case #2
from typing import TypeVar

T = TypeVar('T')
U = TypeVar('U')

def are_equal(a: T, b: U) -> bool:
    return a == b

are_equal(10, 10.0)

// Not Supported. But probably plan to support in Go 2 version.
// <https://blog.golang.org/why-generics>

function are_equal<T, U>(a: T, b: U): boolean {
    return +a == +b;
}

are_equal<number, number>(10, 10.0);

Iterate through Array

std::string foo[] = {"A", "B", "C"};
for (std::string f : foo) {
    std::cout << f << std::endl;
}

String[] foo = new String[]{"A", "B", "C"};
for (String f : foo) {
    System.out.println(f);
}

foo = ['A', 'B', 'C']
for f in foo:
    print(f)

var foo = []string{"A", "B", "C"}
for _, f := range foo {
    fmt.Println(f)
}

let foo: string[] = ['A', 'B', 'C'];
for (const f of foo) {
    console.log(f);
}

Structs

struct Product {
    int weight;
    double price;
};

Product apple;
apple.price = 10;

class Product {
    private int weight;
    private double price;

    public void setPrice(double price) {
        this.price = price;
    }
}

Product apple = new Product();
apple.setPrice(10);

from dataclasses import dataclass

# Data Classes module is only work in Python 3.7 and above.
# A backport of the module for Python 3.6 <https://pypi.org/project/dataclasses/>
@dataclass
class Product:
    weight: int = None
    price: float = None

apple = Product()
apple.price = 10

type Product struct {
	weight int
	price float64
}

var apple Product
apple.price = 10

interface Product {
    weight: number,
    price: number,
}

let apple = {} as Product;
apple.price = 10;

Classes

class Rectangle {
    int width, height;
public:
    Rectangle(int, int);

    int area();
};

Rectangle::Rectangle(int x, int y) {
    width = x;
    height = y;
}

int Rectangle::area() {
    return width * height;
}

Rectangle rect(3, 4);
std::cout << rect.area() << std::endl;

class Rectangle {
    int width;
    int height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int area() {
        return this.width * this.height;
    }
}

Rectangle rect = new Rectangle(3, 4);
System.out.println(rect.area());

from dataclasses import dataclass

@dataclass
class Rectangle:
    width: int
    height: int

    def area(self):
        return self.width * self.height

rect = Rectangle(3, 4)
print(rect.area())

type Geometry interface {
	area() int
}

type Rectangle struct {
	width  int
	height int
}

func (r *Rectangle) area() int {
	return r.width * r.height
}

var rect Geometry = &Rectangle{3, 4}
fmt.Println(rect.area())

class Rectangle {
    width: number;
    height: number;

    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }

    area(): number {
        return this.width * this.height;
    }
}

const rect = new Rectangle(3, 4);
console.log(rect.area());

Inheritance

class Animal {
protected:
    std::string name;
public:
    Animal(std::string n) {
        name = n;
    }

    void move(int);
};

void Animal::move(int distanceInMeters = 0) {
    std::cout << name << " moved " << distanceInMeters << "m." << std::endl;
}

class Horse : Animal {
public:
    Horse(std::string n) : Animal(n) {}

    void move(int);
};

void Horse::move(int distanceInMeters = 45) {
    std::cout << "Galloping..." << std::endl;
    Animal::move(distanceInMeters);
}

Horse tom("Tommy");
tom.move(34);

public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void move(int distanceInMeters) {
        System.out.printf("%s moved %dm.%n", this.name, distanceInMeters);
    }
}

public class Horse extends Animal {
    public Horse(String name) {
        super(name);
    }

    public void move(int distanceInMeters) {
        System.out.println("Galloping...");
        super.move(distanceInMeters);
    }
}

Animal tom = new Horse("Tommy");
tom.move(34);

from dataclasses import dataclass

@dataclass
class Animal:
    name: str

    def move(self, distanceInMeters: int = 0):
        print('%s moved %sm.' % (self.name, distanceInMeters))

class Horse(Animal):
    def move(self, distanceInMeters: int = 45):
        print('Galloping...')
        super().move(distanceInMeters)

tom: Animal = Horse('Tommy')
tom.move(34)

type Animal struct {
	name string
}

func (a *Animal) move(distanceInMeters int) {
	fmt.Printf("%s moved %d.\n", a.name, distanceInMeters)
}

type Horse struct {
	*Animal
}

func (h *Horse) move(distanceInMeters int) {
	fmt.Println("Galloping...")
	h.Animal.move(distanceInMeters)
}

var tom *Horse = &Horse{&Animal{name: "Tommy"}}
tom.move(34)

class Animal {
    name: string;
    constructor(theName: string) {
        this.name = theName;
    }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

class Horse extends Animal {
    constructor(name: string) {
        super(name);
    }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters);
    }
}

let tom: Animal = new Horse("Tommy");
tom.move(34);