Pointers and Value Semantics

package main

import "fmt"

type Book struct {
	Title string
	Year  int
}

func main() {
	year := 1965
	p := &year // p has type *int and holds the address of year
	fmt.Println(*p, p == &year)

	*p = 1966 // writing through the pointer changes year
	fmt.Println(year)

	pp := &p // pointer to pointer
	**pp = 1967
	fmt.Println(year)

	// Pointers to structs: the selector auto-dereferences.
	b := Book{"Dune", 1965}
	pb := &b
	pb.Year++ // same as (*pb).Year++
	fmt.Println(b, (*pb).Title)

	// The zero value of any pointer is nil.
	var np *Book
	fmt.Println(np == nil, np)
	fmt.Printf("%T %v\n", np, np)

	// Pointers to arrays can be indexed and ranged over directly.
	arr := [3]int{10, 20, 30}
	pa := &arr
	pa[1] = 21
	for i, v := range pa {
		fmt.Print(i, "=", v, " ")
	}
	fmt.Println(len(pa))
}

1965 true
1966
1967
{Dune 1966} Dune
true <nil>
*main.Book <nil>
0=10 1=21 2=30 3

package main

import (
	"fmt"
	"io"
	"strings"
)

type Book struct{ Title string }

type Shelf struct{ Books map[string]Book }

func load() Book { return Book{"Dune"} }

func main() {
	m := map[string]Book{"a": {"Dune"}}
	p := &m["a"]
	q := &load()
	m["a"].Title = "Emma"
	s := Shelf{m}
	s.Books["a"].Title = "Ulysses"

	var r io.Reader = strings.NewReader("x")
	pr := &r
	pr.Read(nil)
	fmt.Println(p, q)
}

# example.com/w5/ce/q11
./main.go:17:8: invalid operation: cannot take address of m["a"] (map index expression of struct type Book)
./main.go:18:8: invalid operation: cannot take address of load() (value of struct type Book)
./main.go:19:2: cannot assign to struct field m["a"].Title in map
./main.go:21:2: cannot assign to struct field s.Books["a"].Title in map
./main.go:25:5: pr.Read undefined (type *io.Reader is pointer to interface, not interface)

package main

import "fmt"

type Book struct{ Title string }

func main() {
	var b Book
	var p *Book = b
	var pp **Book = &b
	var np *Book
	if np == 0 {
		fmt.Println("zero")
	}
	var q *int
	var r *int64
	fmt.Println(q == r, p, pp)
}

# example.com/w5/ce/q12
./main.go:9:16: cannot use b (variable of struct type Book) as *Book value in variable declaration
./main.go:10:18: cannot use &b (value of type *Book) as **Book value in variable declaration
./main.go:12:11: invalid operation: np == 0 (mismatched types *Book and untyped int)
./main.go:17:19: invalid operation: q == r (mismatched types *int and *int64)

package main

import "fmt"

type Book struct{ Title string }

func (b *Book) Describe() string {
	if b == nil { // a nil receiver is legal and can be handled
		return "no book"
	}
	return b.Title
}

func main() {
	var b *Book
	fmt.Println(b.Describe()) // calling a method on a nil pointer is fine

	defer func() { fmt.Println("recovered:", recover()) }()
	fmt.Println(b.Title) // dereferencing nil panics
}

no book
recovered: runtime error: invalid memory address or nil pointer dereference

package main

import "fmt"

type Book struct {
	Title string
	Year  int
}

func ptr[T any](v T) *T { return &v } // the pre-1.26 helper

func main() {
	// new(T): pointer to a zero value.
	n := new(int)
	b := new(Book)
	fmt.Println(*n, *b)

	// Go 1.26: new takes an expression; the pointer points to a variable holding its value.
	year := new(1965)
	title := new("Dune")
	later := new(*year + 1)
	fmt.Println(*year, *title, *later)

	fmt.Printf("%T %T\n", year, title)

	// It is handy for optional fields (JSON, SQL, protobuf style).
	type Update struct {
		Title *string
		Year  *int
	}
	u := Update{Title: new("Dune Messiah"), Year: new(1969)}
	fmt.Println(*u.Title, *u.Year)

	old := ptr(1965)
	fmt.Println(*old)

	// Address of a composite literal: allowed, the variable is allocated for you.
	pb := &Book{Title: "Emma", Year: 1815}
	fmt.Println(pb.Title)
	// new(Book{...}) also works in 1.26.
	pc := new(Book{Title: "Ulysses", Year: 1922})
	fmt.Println(*pc)
}

0 { 0}
1965 Dune 1966
*int *string
Dune Messiah 1969
1965
Emma
{Ulysses 1922}

# example.com/q3old
./main.go:19:10: new(1965) requires go1.26 or later (-lang was set to go1.25; check go.mod)
./main.go:20:11: new("Dune") requires go1.26 or later (-lang was set to go1.25; check go.mod)
./main.go:21:11: new(*year + 1) requires go1.26 or later (-lang was set to go1.25; check go.mod)
./main.go:31:21: new("Dune Messiah") requires go1.26 or later (-lang was set to go1.25; check go.mod)
./main.go:31:48: new(1969) requires go1.26 or later (-lang was set to go1.25; check go.mod)
./main.go:41:8: new(Book{…}) requires go1.26 or later (-lang was set to go1.25; check go.mod)

package main

import "fmt"

type Book struct {
	Title string
	Year  int
}

func main() {
	books := []Book{{"Dune", 1965}, {"Emma", 1815}}

	// range copies each element: modifying the copy changes nothing.
	for _, b := range books {
		b.Year = 0
	}
	fmt.Println(books)

	// Index to modify in place, or take the address of the element.
	for i := range books {
		p := &books[i]
		p.Year++
	}
	fmt.Println(books)

	// Per-iteration variables (Go 1.22+): &b is a different address on each iteration.
	var ptrs []*Book
	for _, b := range books {
		ptrs = append(ptrs, &b)
	}
	fmt.Println(ptrs[0].Title, ptrs[1].Title, ptrs[0] != ptrs[1])

	// A pointer into a slice keeps the OLD backing array alive after append reallocates.
	first := &books[0]
	books = append(books, Book{"Ulysses", 1922}) // len 2 == cap 2: reallocates
	first.Title = "Changed"
	fmt.Println(books[0].Title, first.Title)
}

[{Dune 1965} {Emma 1815}]
[{Dune 1966} {Emma 1816}]
Dune Emma true
Dune Changed

package main

import "fmt"

type ISBN string

type Author struct{ Name string }

type Book struct {
	ISBN   ISBN
	Author *Author
}

func main() {
	a := &Author{"Herbert"}
	b1 := Book{"1", a}
	b2 := Book{"1", a}
	b3 := Book{"1", &Author{"Herbert"}}

	// Pointers compare by address; structs compare field by field, including the pointer.
	fmt.Println(b1 == b2, b1 == b3, *b1.Author == *b3.Author)

	x, y := 1, 1
	px, py := &x, &y
	fmt.Println(px == py, *px == *py, px == &x)

	// Pointers are valid map keys: identity, not content.
	seen := map[*Author]bool{a: true}
	fmt.Println(seen[a], seen[&Author{"Herbert"}])
}

true false true
false true true
true false

package main

import (
	"fmt"
	"sync"
)

type Store struct {
	mu    sync.Mutex
	books map[string]int
}

// Value receiver: copies the mutex. go vet reports this.
func (s Store) Count() int {
	s.mu.Lock()
	defer s.mu.Unlock()
	return len(s.books)
}

func main() {
	s := Store{books: map[string]int{"Dune": 1}}
	t := s // copies the lock too
	fmt.Println(s.Count(), len(t.books))
}

q06/main.go:14:9: Count passes lock by value: example.com/w5/q06.Store contains sync.Mutex
q06/main.go:22:7: assignment copies lock value to t: example.com/w5/q06.Store contains sync.Mutex

package main

import "fmt"

// noCopy has no fields; its Lock/Unlock methods make go vet's copylocks check
// flag any copy of a struct that contains it.
type noCopy struct{}

func (*noCopy) Lock()   {}
func (*noCopy) Unlock() {}

type Index struct {
	_     noCopy
	words map[string]int
}

func NewIndex() *Index { return &Index{words: map[string]int{}} }

func (ix *Index) Add(w string) { ix.words[w]++ }

func report(ix Index) int { return len(ix.words) } // copies the lock-like value

func main() {
	ix := NewIndex()
	ix.Add("dune")
	fmt.Println(report(*ix))
	cp := *ix
	fmt.Println(len(cp.words))
}

q08/main.go:21:16: report passes lock by value: example.com/w5/q08.Index contains example.com/w5/q08.noCopy
q08/main.go:26:21: call of report copies lock value: example.com/w5/q08.Index contains example.com/w5/q08.noCopy
q08/main.go:27:8: assignment copies lock value to cp: example.com/w5/q08.Index contains example.com/w5/q08.noCopy