GO Go · 20 вопросов · ~55 мин · ⏱ Таймер 55:00 · Лёгкий ·

Указатели без арифметики

Проверяет адрес, разыменование, изменение через указатель, `nil` и время жизни значения без ухода в `unsafe`. В тесте 20 вопросов, из них 12 требуют чтения кода, команд или диагностических фрагментов. Задания опираются на устойчивые правила современного Go; если поведение зависит от версии, это оговорено в самом вопросе.

Отвечено: 0 из 20

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 20 вопросов отведено 55 минут. В каждом вопросе верен только один вариант. После завершения вы увидите общий результат и результаты по 4 тематическим шкалам с объяснениями и практическими рекомендациями.

Вопрос 1 из 20

Перед публикацией кода по теме «Адрес» нужно уточнить контракт. Какое наблюдение о работе кода будет верным?

// Фрагмент для трассировки.
package main
func main(){ n:=3; p:=&n; _ = p == &n }

После `b := a` изменение `b[0]` не меняет `a[0]`, потому что массив скопирован как значение. Вызов `p.Move()` не меняет `p.X`, потому что получатель `Point` скопирован. `Admin` получает продвинутый метод `Name`, однако значение `Admin` нельзя передать туда, где требуется конкретный `User`. `p := &n` создаёт указатель на `n`, и сравнение `p == &n` истинно в рамках этого значения. После `b := a` поле-срез в обеих структурах указывает на один массив, поэтому изменение элемента видно через обе копии.

Вопрос 2 из 20

В рабочем примере по теме «Адрес» важно отделить гарантию от догадки. Какую правку разумнее внести до объединения изменений?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main(){ n:=3; p:=&n; _ = p == &n }

Копировать данные через `copy` или `append([]T(nil), src...)`, когда нужен независимый снимок. Передавать адрес только когда требуется общая мутация, идентичность или избегание значимой копии. Использовать значимый получатель для небольших неизменяемых значений и указательный — когда метод меняет состояние или копирование дорого. Всегда присваивать результат `append` обратно нужной переменной и не полагаться на сохранение адреса элементов. Передавать большой массив указателем либо срезом, если полная копия не является частью замысла.

Вопрос 3 из 20

Фрагмент относится к теме «Адрес». Какое правило Go непосредственно объясняет поведение фрагмента?

// Определите правило Go, которое объясняет результат.
package main
func main(){ n:=3; p:=&n; _ = p == &n }

Метод со значимым получателем работает с копией значения; изменения обычных полей не сохраняются в исходной структуре. Оператор `&` получает адрес адресуемого значения; получившийся указатель имеет тип `*T`. Встраивание продвигает поля и методы, но не превращает внешний тип в подтип встроенного. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные. Длина входит в тип массива; `[3]int` и `[4]int` — разные типы, а присваивание массива копирует все элементы.

Вопрос 4 из 20

На ревью разбирают тему «Адрес». Где заканчивается гарантия показанного приёма?

Сравнение массивов допустимо только тогда, когда тип их элементов сравним. Даже значимый получатель может менять объект через ссылочное поле, например элемент общего среза. Конфликтующие продвинутые имена требуют явного указания пути и не выбираются произвольно. Указатель на элемент среза может стать указателем на старый массив после перераспределения при `append`. Нельзя взять адрес элемента карты, потому что элементы карты не являются адресуемыми значениями.

Вопрос 5 из 20

В разделе «Адрес» показан конкретный случай. Когда этот приём помогает, а когда начинает мешать?

Встраивание сокращает делегирование, но слишком глубокая композиция скрывает происхождение методов. Структуры удобны как значения, но наличие карт, срезов и указателей требует отдельно определить семантику копирования. Значимые методы поддерживают семантику значения, но крупные структуры могут копироваться дороже и случайно разделять внутренние ссылки. Совместное владение экономит копирование, но требует ясного контракта мутации и времени жизни данных. Указатель избегает копирования и передаёт идентичность, но увеличивает число разделяемых состояний и проверок `nil`.

Вопрос 6 из 20

В рабочем примере по теме «Разыменование» важно отделить гарантию от догадки. Каков наблюдаемый результат этого кода?

// Фрагмент для трассировки.
package main
func main(){ n:=1; p:=&n; *p=8; _=n }

Вызов `p.Move()` корректен для переменной `p`: компилятор использует `(&p).Move()`, и `X` станет 1. После `*p = 8` исходная переменная `n` равна 8. После первого `append` с достаточной ёмкостью новый элемент записывается в тот же массив; после исчерпания ёмкости возможен новый массив. `Admin` получает продвинутый метод `Name`, однако значение `Admin` нельзя передать туда, где требуется конкретный `User`. После `b := a` поле-срез в обеих структурах указывает на один массив, поэтому изменение элемента видно через обе копии.

Вопрос 7 из 20

Фрагмент относится к теме «Разыменование». Какое изменение лучше всего укрепит контракт этого фрагмента?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main(){ n:=1; p:=&n; *p=8; _=n }

Делать глубокую копию ссылочных полей, если копия структуры должна владеть независимым состоянием. Передавать большой массив указателем либо срезом, если полная копия не является частью замысла. Использовать значимый получатель для небольших неизменяемых значений и указательный — когда метод меняет состояние или копирование дорого. Проверять возможность `nil` на границе и не разносить необязательный указатель глубже без необходимости. Проверять `nil`-получатель только если методы типа действительно обещают осмысленное поведение для `nil`.

Вопрос 8 из 20

На ревью разбирают тему «Разыменование». Какое утверждение точнее всего описывает действующую гарантию?

// Определите правило Go, которое объясняет результат.
package main
func main(){ n:=1; p:=&n; *p=8; _=n }

Оператор `*p` читает или изменяет значение по адресу; разыменование `nil` вызывает панику. Метод с получателем `*T` может менять исходное значение; компилятор часто автоматически берёт адрес адресуемой переменной. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные. Метод со значимым получателем работает с копией значения; изменения обычных полей не сохраняются в исходной структуре. Встраивание продвигает поля и методы, но не превращает внешний тип в подтип встроенного.

Вопрос 9 из 20

В разделе «Разыменование» показан конкретный случай. Что может изменить вывод при небольшом изменении условий?

Даже значимый получатель может менять объект через ссылочное поле, например элемент общего среза. Конфликтующие продвинутые имена требуют явного указания пути и не выбираются произвольно. Указатель на указатель имеет другой уровень разыменования и не заменяется автоматически обычным указателем. Маленький подсрез способен удерживать в памяти большой базовый массив. Сравнение массивов допустимо только тогда, когда тип их элементов сравним.

Вопрос 10 из 20

Команда проверяет решение по теме «Разыменование». Как решение влияет на читаемость и надёжность?

Явное разыменование показывает мутацию, но API с множеством указателей часто сигнализирует о неясном владении. Структуры удобны как значения, но наличие карт, срезов и указателей требует отдельно определить семантику копирования. Массив фиксирует размер в типе и полезен для точных структур, но срез гибче на границах API. Предварительный `make` с разумной ёмкостью ускоряет рост, но точная оценка не должна превращаться в удержание огромного массива. Встраивание сокращает делегирование, но слишком глубокая композиция скрывает происхождение методов.

Вопрос 11 из 20

Фрагмент относится к теме «Изменение значения». Что увидит вызывающий код после выполнения?

// Фрагмент для трассировки.
package main
func inc(p *int){ (*p)++ }
func main(){ n:=1; inc(&n); _=n }

Значение `n` остаётся равным 1: указатель передаётся по значению, поэтому запись через него не видна вызывающему коду. Код не компилируется: оператор `++` нельзя применять к разыменованному указателю `*p`. Значение `n` остаётся равным 1: выражение `*p` создаёт временную копию числа, которую и увеличивает функция. Функция `inc(&n)` увеличивает `n` до 2. Код не компилируется: адрес локальной переменной `n` нельзя передавать в другую функцию.

Вопрос 12 из 20

На ревью разбирают тему «Изменение значения». Как подготовить этот код к реальному использованию?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func inc(p *int){ (*p)++ }
func main(){ n:=1; inc(&n); _=n }

Возвращать новое значение вместо мутации, если это делает поток данных проще и копирование недорого. Проверять `nil`-получатель только если методы типа действительно обещают осмысленное поведение для `nil`. Использовать встраивание для композиции поведения, а не для имитации наследования и неявной подстановки типов. Делать глубокую копию ссылочных полей, если копия структуры должна владеть независимым состоянием. Копировать данные через `copy` или `append([]T(nil), src...)`, когда нужен независимый снимок.

Вопрос 13 из 20

В разделе «Изменение значения» показан конкретный случай. Какой контракт определяет результат показанного кода?

// Определите правило Go, которое объясняет результат.
package main
func inc(p *int){ (*p)++ }
func main(){ n:=1; inc(&n); _=n }

Передача `*T` позволяет функции менять исходное значение, потому что копируется сам адрес, указывающий на тот же объект. Длина входит в тип массива; `[3]int` и `[4]int` — разные типы, а присваивание массива копирует все элементы. Метод со значимым получателем работает с копией значения; изменения обычных полей не сохраняются в исходной структуре. Два среза могут видеть один базовый массив; запись через один срез отражается в другом, если их диапазоны пересекаются. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные.

Вопрос 14 из 20

Команда проверяет решение по теме «Изменение значения». Какое допущение здесь чаще всего оказывается ложным?

Сравнение массивов допустимо только тогда, когда тип их элементов сравним. Даже значимый получатель может менять объект через ссылочное поле, например элемент общего среза. Сравнивать структуру оператором `==` можно только тогда, когда сравнимы все её поля. Конфликтующие продвинутые имена требуют явного указания пути и не выбираются произвольно. Переназначение локального параметра-указателя не меняет указатель у вызывающего кода.

Вопрос 15 из 20

Перед публикацией кода по теме «Изменение значения» нужно уточнить контракт. Какое замечание о цене решения будет точным?

Встраивание сокращает делегирование, но слишком глубокая композиция скрывает происхождение методов. Массив фиксирует размер в типе и полезен для точных структур, но срез гибче на границах API. Структуры удобны как значения, но наличие карт, срезов и указателей требует отдельно определить семантику копирования. Совместное владение экономит копирование, но требует ясного контракта мутации и времени жизни данных. Мутация через указатель удобна для состояния, но чистая функция проще для параллельного использования и тестов.

Вопрос 16 из 20

На ревью разбирают тему «Время жизни». Что гарантированно произойдёт в показанной последовательности операций?

// Фрагмент для трассировки.
package main
func makeInt() *int { n:=7; return &n }
func main(){ p:=makeInt(); _=*p }

Вызов `p.Move()` корректен для переменной `p`: компилятор использует `(&p).Move()`, и `X` станет 1. `Admin` получает продвинутый метод `Name`, однако значение `Admin` нельзя передать туда, где требуется конкретный `User`. `makeInt` возвращает корректный указатель; значение не исчезает после выхода из функции. После `b := a` поле-срез в обеих структурах указывает на один массив, поэтому изменение элемента видно через обе копии. После `b := a` изменение `b[0]` не меняет `a[0]`, потому что массив скопирован как значение.

Вопрос 17 из 20

В разделе «Время жизни» показан конкретный случай. Какой вариант исправления соответствует обычной практике Go?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func makeInt() *int { n:=7; return &n }
func main(){ p:=makeInt(); _=*p }

Использовать значимый получатель для небольших неизменяемых значений и указательный — когда метод меняет состояние или копирование дорого. Ориентироваться на семантику владения, а не вручную угадывать стек или кучу; измерять аллокации при реальной необходимости. Делать глубокую копию ссылочных полей, если копия структуры должна владеть независимым состоянием. Всегда присваивать результат `append` обратно нужной переменной и не полагаться на сохранение адреса элементов. Использовать встраивание для композиции поведения, а не для имитации наследования и неявной подстановки типов.

Вопрос 18 из 20

Команда проверяет решение по теме «Время жизни». Какой принцип языка объясняет результат полностью?

// Определите правило Go, которое объясняет результат.
package main
func makeInt() *int { n:=7; return &n }
func main(){ p:=makeInt(); _=*p }

Компилятор может разместить локальное значение в куче, если указатель на него переживает вызов; возвращать такой указатель безопасно. Метод с получателем `*T` может менять исходное значение; компилятор часто автоматически берёт адрес адресуемой переменной. `append` может использовать прежний базовый массив либо выделить новый; это зависит от ёмкости. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные. Метод со значимым получателем работает с копией значения; изменения обычных полей не сохраняются в исходной структуре.

Вопрос 19 из 20

Перед публикацией кода по теме «Время жизни» нужно уточнить контракт. Какой предел контракта важен для вызывающего кода?

Даже значимый получатель может менять объект через ссылочное поле, например элемент общего среза. Указатель на элемент среза может стать указателем на старый массив после перераспределения при `append`. Маленький подсрез способен удерживать в памяти большой базовый массив. Escape analysis может изменить размещение после небольшой правки или обновления компилятора. Нельзя автоматически взять адрес результата функции или другого неадресуемого значения для вызова указательного метода.

Вопрос 20 из 20

В рабочем примере по теме «Время жизни» важно отделить гарантию от догадки. Как решение скажется на тестировании и дальнейших изменениях?

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

Ответьте на все 20 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу