Концептуальные различия

Синтаксис

Go                           C++
var v1 int                // int v1;
var v2 string             // const std::string v2;  (примерно)
var v3 [10]int            // int v3[10];
var v4 []int              // int* v4;  (примерно)
var v5 struct { f int }   // struct { int f; } v5;
var v6 *int               // int* v6;  (но нет арифметики для указателей)
var v7 map[string]int     // unordered_map* v7;  (примерно)
var v8 func(a int) int    // int (*v8)(int a);

var (
    i int
    m float
)

func f(i, j, k int, s, t string)

var v = *p

v1 := v2

var v1 = v2

i, j = j, i    // Поменять местами значения i и j.

func f() (i int, j int) { ... }
v1, v2 = f()

func g()
{                  // НЕВЕРНО
}

if x {
}
else {             // НЕВЕРНО
}

type myStruct struct { i int }
var v9 myStruct              // v9 является структурой
var p9 *myStruct             // p9 указатель на структуру
f(v9.i, p9.i)

if a < b { f() }             // Корректно
if (a < b) { f() }           // Корректно
if (a < b) f()               // НЕКОРРЕКТНО
for i = 0; i < 10; i++ {}    // Корректно
for (i = 0; i < 10; i++) {}  // НЕКОРРЕКТНО

switch i {
case 0:  // пустое тело case
case 1:
    f()  // f не вызовется, когда i == 0!
}

switch i {
case 0, 1:
    f()  // f будет вызвана если i == 0 || i == 1.
}

switch {
case i < 0:
    f1()
case i == 0:
    f2()
case i > 0:
    f3()
}

fd := open("filename")
defer close(fd)         // fd будет закрыта после завершения функции

Константы

var a uint
f(a + 1)  // Численная константа без типа "1" становится типа uint

const huge = 1 << 100
f(huge >> 98)

const (
    red = iota   // red == 0
    blue         // blue == 1
    green        // green == 2
)

Срезы

Создание значений

Интерфейсы

type myType struct { i int }
func (p *myType) get() int { return p.i }

type myInteger int
func (p myInteger) get() int { return int(p) } // Требуется преобразование.
func f(i int) { }
var v myInteger
// f(v) некорректно.
// f(int(v)) корректо; у int(v) нет определенных методов.

type myInterface interface {
	get() int
	set(i int)
}

func (p *myType) set(i int) { p.i = i }

func getAndSet(x myInterface) {}
func f1() {
	var p myType
	getAndSet(&p)
}

type myChildType struct { myType; j int }
func (p *myChildType) get() int { p.j++; return p.myType.get() }

func f2() {
	var p myChildType
	getAndSet(&p)
}

type myPrintInterface interface {
  print()
}
func f3(x myInterface) {
	x.(myPrintInterface).print()  // утверждение типа к myPrintInterface
}

type Any interface { }
type iterator interface {
	get() Any
	set(v Any)
	increment()
	equal(arg *iterator) bool
}

Go-процедуры

func server(i int) {
    for {
        print(i)
        sys.sleep(10)
    }
}
go server(1)
go server(2)

var g int
go func(i int) {
	s := 0
	for j := 0; j < i; j++ { s += j }
	g = s
}(1000)

Каналы

type cmd struct { get bool; val int }
func manager(ch chan cmd) {
	var val int = 0
	for {
		c := <- ch
		if c.get { c.val = val; ch <- c }
		else { val = c.val }
	}
}

type cmd2 struct { get bool; val int; ch <- chan int }
func manager2(ch chan cmd2) {
	var val int = 0
	for {
		c := <- ch
		if c.get { c.ch <- val }
		else { val = c.val }
	}
}

func f4(ch <- chan cmd2) int {
	myCh := make(chan int)
	c := cmd2{ true, 0, myCh }   // Composite literal syntax.
	ch <- c
	return <-myCh
}