//go:build ignore

// Указатели: три наблюдения, добавленные после внешнего аудита 14.10.2026.
//
// ЗАЧЕМ ОТДЕЛЬНАЯ ПРОГРАММА. internals.go цитируется в уроке блоками, и
// менять его вывод значит ломать цитаты. Здесь — то, чего в нём не хватало:
//
//  1. new(T) и &T{} одинаковы для структуры, но не для среза и карты:
//     new даёт указатель на НУЛЕВОЕ значение (nil-срез, nil-карта), а &T{} —
//     на пустой, но инициализированный контейнер. В nil-карту писать нельзя.
//  2. Указатель на элемент после перевыделения массива не «испорчен»: читать
//     и писать через него законно, он просто больше не связан с текущим
//     массивом среза — и удерживает старый массив в памяти.
//  3. Число выделений у функции, возвращающей адрес своей переменной, зависит
//     от места вызова: встроенная копия, чей указатель не ушёл наружу,
//     обходится без кучи. Число выделений — наблюдение реализации, а не
//     правило языка.
//
// Числа в мегабайтах округлены вниз до целого; HeapAlloc снят сразу после
// runtime.GC().
//
// ЗАПУСК:
//
//	go run bench/goptr/audit.go
package main

import (
	"fmt"
	"runtime"
	"strings"
	"testing"
)

func show(title string) {
	fmt.Println()
	fmt.Println(title)
	fmt.Println(strings.Repeat("─", len([]rune(title))))
}

func panicText(f func()) (msg string) {
	defer func() {
		if r := recover(); r != nil {
			msg = fmt.Sprint(r)
		}
	}()
	f()
	return ""
}

type Point struct{ X, Y int }

// newCounterInl может быть встроена: //go:noinline нет.
func newCounterInl() *int {
	c := 0
	return &c
}

// newCounter не встраивается — как в internals.go.
//
//go:noinline
func newCounter() *int {
	c := 0
	return &c
}

var sinkP *int
var sinkN int

func heapMB() uint64 {
	runtime.GC()
	var ms runtime.MemStats
	runtime.ReadMemStats(&ms)
	return ms.HeapAlloc >> 20
}

func main() {
	fmt.Printf("%s %s/%s | указатели: дополнения после аудита\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)

	show("1) new(T) И &T{} ДЛЯ СТРУКТУРЫ, СРЕЗА И КАРТЫ")
	fmt.Println("  T                  *new(T)              *(&T{})")
	fmt.Printf("  Point              %-20s %s\n", fmt.Sprintf("%+v", *new(Point)), fmt.Sprintf("%+v", *(&Point{})))
	fmt.Printf("  []int              == nil: %-12v == nil: %v\n", *new([]int) == nil, *(&[]int{}) == nil)
	fmt.Printf("  map[string]int     == nil: %-12v == nil: %v\n", *new(map[string]int) == nil, *(&map[string]int{}) == nil)
	fmt.Println()
	fmt.Println("  запись (*m)[\"k\"] = 1:")
	mn := new(map[string]int)
	fmt.Printf("    m := new(map[string]int)    -> паника: %s\n", panicText(func() { (*mn)["k"] = 1 }))
	ml := &map[string]int{}
	(*ml)["k"] = 1
	fmt.Printf("    m := &map[string]int{}      -> len %d\n", len(*ml))
	fmt.Println("  *s = append(*s, 1):")
	sn := new([]int)
	*sn = append(*sn, 1)
	fmt.Printf("    s := new([]int)             -> len %d   (append в nil-срез законен)\n", len(*sn))
	sl := &[]int{}
	*sl = append(*sl, 1)
	fmt.Printf("    s := &[]int{}               -> len %d\n", len(*sl))

	show("2) СТАРЫЙ МАССИВ ПОСЛЕ ПЕРЕВЫДЕЛЕНИЯ")
	s := make([]byte, 8<<20)
	e := &s[0]
	s = append(s, 1)
	fmt.Println("  s := make([]byte, 8 МБ); e := &s[0]; s = append(s, 1)")
	*e = 5
	fmt.Printf("  *e = 5; *e, s[0]                -> %d %d   (запись законна, но в старый массив)\n", *e, s[0])
	fmt.Printf("  живая куча после GC, e жив      -> %d МБ\n", heapMB())
	runtime.KeepAlive(e)
	e = nil
	fmt.Printf("  живая куча после GC, e = nil    -> %d МБ\n", heapMB())
	runtime.KeepAlive(s)
	fmt.Println("  Пока жив e, жив и весь старый массив в 8 МБ.")

	show("3) ВЫДЕЛЕНИЯ ЗАВИСЯТ ОТ МЕСТА ВЫЗОВА")
	fmt.Println("  newCounterInl встраивается (//go:noinline нет):")
	fmt.Printf("    p := newCounterInl(); *p++; sinkN = *p  -> %.0f\n",
		testing.AllocsPerRun(1000, func() { p := newCounterInl(); *p++; sinkN = *p }))
	fmt.Printf("    sinkP = newCounterInl()                 -> %.0f\n",
		testing.AllocsPerRun(1000, func() { sinkP = newCounterInl() }))
	fmt.Println("  newCounter с //go:noinline:")
	fmt.Printf("    p := newCounter(); *p++; sinkN = *p     -> %.0f\n",
		testing.AllocsPerRun(1000, func() { p := newCounter(); *p++; sinkN = *p }))
	fmt.Println("  Выделений на вызов, testing.AllocsPerRun. Один и тот же код")
	fmt.Println("  «return &c» стоит 0 или 1 выделение в зависимости от того, встроен ли")
	fmt.Println("  вызов и уходит ли указатель наружу.")
}