---
title: "Указатели на собеседовании Go: вопросы и ответы с примерами"
description: "Вопросы про указатели в Go на собеседовании: & и *, методы на значении и указателе, указатели в слайсах, nil, new vs &T{}, escape analysis — с кодом и разбором ловушек."
url: "https://golangmaster.ru/interview/ukazateli/"
published: "2026-09-19"
updated: "2026-09-21"
level: "junior"
questions: 9
---

# Указатели на собеседовании Go: вопросы и ответы с примерами

*Уровень: junior. ~20 минут, 9 вопросов. Источник: https://golangmaster.ru/interview/ukazateli/*

Указатели — тема, на которой валится заметная часть junior-интервью по Go, и не потому, что указатели сложны, а потому, что они вскрывают сразу три соседних понятия: семантику копирования, работу методов и разницу стек/куча. Вопрос «что напечатает этот код» со структурой, переданной по значению, моментально отделяет тех, кто понял модель Go, от тех, кто запомнил синтаксис.

Ниже — вопросы, которые реально звучат на собеседованиях, с кодом и разбором типовых ловушек: когда брать указатель в сигнатуре, почему append ломает ссылки на элементы слайса, чем new(T) отличается от &T{}, и куда уходят переменные, адрес которых взяли.

Минимальная теория для этой статьи разобрана в [уроке про указатели](/courses/go-basics/lessons/22-ukazateli/) базового курса — если разбор ниже кажется прыжком в глубину, начните с него. Связка «указатель → куда попадёт переменная» подробно рассматривается в статье про [модель памяти](/interview/model-pamyati/).

## Что такое указатель в Go и зачем он нужен?

Указатель — это переменная, хранящая адрес другой переменной. Оператор &a берёт адрес, *p разыменовывает. Нужны указатели для двух задач. Первая — изменение: аргументы Go копирует всегда, поэтому функция, которой передали структуру по значению, меняет копию; чтобы функция изменила оригинал, передают адрес. Вторая — экономия: большая структура при каждой передаче копируется целиком, указатель — 8 байт на 64-битных системах. Важная оговорка для собеседования: Go НЕ разрешает арифметику указателей, как C — p+1 не компилируется. Это осознанное решение: арифметика адресов — главный источник corruption в C, а без неё указатели в Go безопасны, остаётся только одна ошибка — разыменование nil.

```go
x := 42
p := &x          // p хранит адрес x
*p = 100        // меняем x через указатель
fmt.Println(x)  // 100
```

## Когда брать указатель в сигнатуре функции, а когда значение?

Правило из Effective Go и код-ревью: если функция должна изменить аргумент — указатель; если структура большая (копирование заметно) — указатель; если аргумент маленький и не меняется (int, string, небольшая структура) — значение. Значение безопаснее: callee не может испортить оригинал, и нет риска nil. Указатель в сигнатуре — это контракт «функция может изменить или ожидает не-nil»: каждый вызов заставляет читателя проверить оба варианта. Средний размер структуры (поля на пару сотен байт) — копирование дешевле косвенности через указатель, и тесты проще. Спорную границу решает профилирование, а не вкус: если в flamegraph виден аллокатор из-за передач больших структур — переводите на указатели.

```go
// менять нельзя, структура мала — значение
func area(r Rect) float64 { return r.W * r.H }

// сдвигает оригинал — указатель обязателен
func move(r *Rect, dx int) { r.X += dx }
```

## Методы на значении и на указателе: в чём разница и что ждут от ответа?

Два уровня. Семантика: метод на значении работает с КОПИЕЙ (изменить поле оригинала не может), метод на указателе — с оригиналом. Набор методов: у типа T методы на значении, у *T — и на значении, и на указателе. Отсюда классический вопрос: почему var s fmt.Stringer = myStruct{} компилируется, а := с методом на указателе даёт «myStruct does not implement Stringer (method has pointer receiver)»? Потому что адресуемая переменная авто-разыменовывается в вызове, но в интерфейс попадает копия без набора методов указателя. Практическое правило, которое ждут в ответе: выберите ONE receiver-тип для всех методов типа и не смешивайте; смешение — признак путаницы в семантике и источник сюрпризов с интерфейсами.

```go
type Counter struct{ n int }

func (c *Counter) Inc() { c.n++ }

var c Counter
c.Inc()            // ок: c адресуем, синтаксический сахар
cs := []Counter{{}}
cs[0].Inc()        // тоже ок: элемент слайса адресуем
m := map[string]Counter{}
// m["a"].Inc()    // НЕ скомпилируется: значение мапы не адресуемо
```

## Классика кодинга: слайс указателей на структуры после append — почему ломается?

Ловушка сочетает две вещи: append может перевыделить backing array (когда ёмкость кончилась), а старые указатели продолжают указывать на СТАРЫЙ массив... точнее, указатели на элементы остаются валидными (элементы-то копируются, адреса старых не двигаются), но случай с мапой ломается иначе: взять адрес значения мапы нельзя, а слайс структур, построенный из range-переменной, — можно и нужно. Настоящий вопрос обычно звучит так: почему все элементы слайса указателей указывают на одно и то же? Ответ: в цикле for _, v := range items указатель &v каждый раз указывает на ОДНУ переменную v, которую компилятор использует заново. До Go 1.22 v была одна на весь цикл; в Go 1.22+ переменная создаётся на каждую итерацию, и ловушка исчезла. На собеседовании ждут: знание старого поведения, умение показать фикс (v := v или items[i]) и упоминание, что в 1.22 семантика изменилась.

```go
items := []Item{{"a"}, {"b"}}
var ps []*Item
for _, v := range items {
    ps = append(ps, &v) // до Go 1.22: оба указателя на одну v!
}
// фикс для старых версий:
for i := range items { ps = append(ps, &items[i]) }
```

## Что будет при разыменовании nil-указателя и как защититься?

Паника «runtime error: invalid memory address or nil pointer dereference» — recover её ловит, но правильный стиль — проверять до разыменования. Нюанс, за который дают плюс: в Go разыменование nil структуры НЕ всегда падает — метод на nil-приёмнике валиден. Классика: (*T)(nil) с методом, читающим поле, падает; метод, не трогающий поля (например, логгер без состояния), — работает. Это позволяет паттерны вроде nil-логгера. Для защиты на границах: если функция принимает *T, решите явно — обязателен ли аргумент (тогда паника на nil на входе это баг вызывавшего, документируйте) или допустим (тогда if p == nil внутри). Ответ «сделаю recover» — красный флаг: recover маскирует баги, а не исправляет их.

```go
type Logger struct{ prefix string }

func (l *Logger) Log(s string) {
    if l == nil { // nil-логгер: ничего не делает
        return
    }
    fmt.Println(l.prefix, s)
}
var l *Logger
l.Log("работает") // без паники
```

## new(T) vs &T{} — чем отличаются и что предпочитают?

Функционально почти одинаково: оба дают *T с нулевым значением. new(T) выделяет нулевое значение и возвращает адрес; &T{} создаёт литералом (можно сразу с полями: &T{Name: "x"}) и тоже возвращает адрес. Отличия: new работает с любым типом (&T{} — только с составными: структуры, слайсы, мапы); литерал позволяет инициализацию сразу; new возвращает указатель на нулевое значение, поэтому new(int) часто удобнее для чисел. Идиома кодовой базы Go и большинства ревью: где можно — литерал с полями (читаемее: видно, что инициализировано), new — для случаев без литерала (new(int), new(bytes.Buffer)). На собеседовании главное — не перепутать: new НЕ вызывает конструктора (конструкторов в Go нет), и new(T) для слайса даст *[]T нулевой длины, а не готовый к append слайс.

```go
p1 := new(int)          // *int, 0
p2 := &Rect{W: 3, H: 4} // *Rect с полями
p3 := new([]int)        // *[]int — nil-слайс, len 0
// s := make([]int, 0)  // а слайс обычно делают через make
```

## Указатель на указатель (**T) — когда реально нужен?

Три случая. Первый — изменение самого указателя из функции: reset(p **T) может сделать *p = nil, обычный *T не даст заменить адрес. Второй — в API, отражающие C-библиотеки (cgo) и некоторые драйверы. Третий — неявно: изменение переменной интерфейсного типа через метод иногда требует **T в обходе. В обычном прикладном коде **T — почти всегда сигнал пересмотреть дизайн: проще вернуть новое значение или использовать методы. На собеседовании ждут ровно это: знание синтаксиса, один честный пример (сброс указателя из функции), и зрелый вывод «в чистом Go встречается редко — увидели, проверьте, не обходное ли это решение».

```go
func reset(p **Config) { *p = nil }

cfg := &Config{Timeout: 5}
reset(&cfg)
fmt.Println(cfg == nil) // true
```

## Взятие адреса переменной: всегда ли переменная окажется в heap (escape analysis)?

Нет — и это любимый вопрос про GC. Решает escape analysis компилятора: если переменная, адрес которой взяли, не «убегает» за пределы функции (не возвращается, не сохраняется в глобальные структуры, не уходит в интерфейс), она живёт в стеке, даже с взятым адресом. Классика: p := &T{...}; return p — убегает, аллокация в heap; p := &T{}; use(p) локально — стек, ноль нагрузки на GC. Проверка: go build -gcflags=-m покажет «escapes to heap» / «stack frame». Связь с собеседованием про производительность: указатели не всегда означают аллокации — важен контекст; наоборот, интерфейс (any) часто заставляет значение уходить в heap даже без явного взятия адреса (boxing). Ответ уровня middle: знание о существовании анализа + утилита -gcflags=-m; ответ senior: примеры, как лишний указатель в горячем цикле рождает heap-аллокации и как это видно в pprof.

```go
func stackAlloc() *int {
    x := 42
    return &x // x убегает: heap (компилятор перенесёт)
}

func stackStay() {
    y := 42
    p := &y      // не убегает: стек
    _ = *p + 1
}
```

## Почему нельзя взять адрес элемента мапы, и как обходят?

Внутреннее устройство мапы: элементы переезжают между «ковшами» при росте и рехешировании, поэтому адрес конкретного значения не гарантирован — Go запрещает &m[key] компиляцией: «cannot take the address of m[key]». То же с элементами интерфейса. Обходы по ситуации: временная переменная (v := m[key]; &v — но это копия!), хранить в мапе указатели (map[string]*T — стандартный паттерн для больших структур и мутабельности), или переделать на слайс, где элементы адресуемы. За плюс на собеседовании: объяснить ПОЧЕМУ запрет существует (переехавшие элементы сделали бы старые указатели валидными на мусор), и уверенно назвать map[string]*T идиоматичным решением, а не хаком.

```go
m := map[string]Rect{"a": {3, 4}}
// r := &m["a"]       // не компилируется
v := m["a"]           // копия
vr := &v              // адрес копии, НЕ элемента мапы

pm := map[string]*Rect{}
pm["a"] = &Rect{3, 4}
pr := pm["a"]         // настоящий адрес
```
