Объясните, когда Go автоматически берёт адрес значения структуры для вызова метода с указательным получателем.

Краткий ответ

Go автоматически берёт адрес, если значение структуры адресуемо, например локальная переменная или параметр функции. Поэтому вызов метода с указательным получателем через такую переменную обычно записывается без явного оператора адреса.

Автоматическое взятие адреса не применяется к неадресуемым значениям: результату функции, временному выражению или элементу карты. Кроме того, значение структуры, хранящееся в интерфейсе, не получает автоматически указатель: его набор методов определяется статическим типом значения.

Исторический контекст

В Go методы могут принадлежать как значению типа, так и указателю на него. Такой подход позволяет явно выразить, должен ли метод работать с копией значения или изменять исходный объект.

Чтобы не заставлять разработчика постоянно писать явное взятие адреса для обычных переменных, язык разрешает неявное преобразование адресуемого значения при выборе метода. При этом правила наборов методов остаются строгими, особенно при работе с интерфейсами.

Постановка проблемы

Если разработчик считает, что Go всегда автоматически преобразует значение структуры в указатель, код может неожиданно не скомпилироваться. Это часто проявляется при вызове метода у результата функции, элемента карты или значения, извлечённого из интерфейса.

Есть и практический риск: указательный метод, вызванный через параметр-значение, изменит копию структуры, а не объект у вызывающего кода. Ошибка в понимании адресуемости или копирования приводит либо к ошибке компиляции, либо к незаметному отсутствию ожидаемых изменений.

Подробное решение

Для типа T метод с получателем T входит в набор методов значения T и указателя *T. Метод с получателем *T входит только в набор методов *T.

Если переменная типа T адресуема, выражение вызова метода допускает неявное взятие адреса. Например, для локальной переменной c вызов c.Inc() может быть обработан как вызов через &c.

Минимальный пример:

package main

type Counter struct{ n int }

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

func bump(c Counter) { c.Inc() }

func main() {
    c := Counter{}
    c.Inc()
    bump(c)
}

Переменная c в main и параметр c в bump адресуемы, поэтому вызов допустим. Однако bump получает копию структуры, поэтому изменение остаётся внутри этой копии.

Результат функции неадресуем в нужном для такого вызова смысле: у возвращённого значения нет доступной переменной, адрес которой можно было бы безопасно передать методу. Поэтому для вызова указательного метода сначала сохраняют результат в переменную.

Элемент карты также нельзя напрямую адресовать: карта может перераспределить внутреннее хранилище, а получение элемента возвращает значение. Для изменения структуры в карте обычно извлекают копию, изменяют её через указательный метод, затем записывают обратно.

Указатель на структуру имеет более широкий набор методов, чем сама структура. Это удобно для изменяющих методов, но требует осознанного выбора типа при передаче значения в интерфейс: значение T не удовлетворяет интерфейсу, требующему метод с получателем *T, даже если обычный вызов через адресуемую переменную был бы разрешён.

Ситуация из практики

В обработчике запроса использовалась структура состояния с методом изменения, объявленным на указателе. Разработчик передавал состояние в функцию по значению и видел, что вызов метода компилируется, но после возврата исходное состояние не изменяется.

Рассматривались два варианта. Передавать структуру по значению проще и безопаснее с точки зрения владения данными, но изменения затрагивают только копию. Передавать указатель позволяет изменять исходный объект, однако появляется необходимость учитывать совместное использование объекта и возможные состояния nil.

Выбрали передачу указателя для изменяемого состояния, а для неизменяемых данных оставили передачу по значению. В результате поведение стало очевидным по сигнатурам функций, а случайные изменения копий исчезли.

Что кандидаты часто упускают

1. Почему вызов метода через результат функции может не скомпилироваться?

   Результат функции является неадресуемым значением. Для метода с получателем *T компилятору нужен адрес конкретного значения типа T, но у временного результата нет переменной, адрес которой можно использовать. Решение — присвоить результат адресуемой переменной, затем вызвать метод через неё.

2. Почему значение структуры в интерфейсе не получает адрес автоматически?

   При проверке соответствия интерфейсу учитывается набор методов динамического типа. У T в этот набор входят только методы с получателем T, тогда как методы с получателем *T принадлежат набору указателя. Правило автоматического взятия адреса применяется к адресуемому выражению при обычном вызове метода, но не расширяет набор методов типа внутри интерфейса.

3. Что изменится, если метод с указательным получателем вызвать внутри функции, принимающей структуру по значению?

   Вызов будет допустим, поскольку параметр функции — адресуемая переменная. Но метод получит адрес параметра, то есть изменит локальную копию структуры. Чтобы изменить структуру вызывающего кода, функция должна принимать указатель либо возвращать изменённую структуру и использовать возвращённое значение.