Умные указатели — бесплатный тест онлайн

Вопрос 1 из 25

Какое свойство «Указатель Box» сохранится после небольшого рефакторинга?

Box автоматически создаёт совместное владение одним значением. Box<T> владеет одним T в куче, имеет стабильный известный размер указателя и освобождает T при Drop владельца Box. Цикл Rc освобождается, когда локальные переменные выходят из области. Тогда различия между обычным и граничным случаем для «Указатель Box» исчезли бы. Weak учитывается в strong_count и не даёт значению освободиться. Следовательно, для «Указатель Box» не понадобилось бы явное предусловие. Arc делает внутренний T автоматически потокобезопасным независимо от Send и Sync.

Вопрос 2 из 25

Какой граничный случай важнее всего учесть для механизма «Счётчик ссылок Rc»?

Цикл сильных Rc не освобождается автоматически; ссылки назад или наблюдатели должны быть Weak либо структура должна разрывать цикл явно. Успешный Weak::upgrade в одном месте гарантирует существование владельца до конца функции без хранения Rc. Если тест не вызвал panic RefCell, все возможные порядки заимствований безопасны. Тогда поведение «Счётчик ссылок Rc» при раннем выходе выводили бы из обычного пути. Цикл ссылок можно не проверять, когда программа завершается вскоре после его создания. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Drop последнего Rc всегда запускается в том же порядке, что создание всех клонов. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются.

Вопрос 3 из 25

Какие значения останутся доступными после `std::sync::Arc`?

use std::sync::Arc;
use std::thread;
let value = Arc::new(String::from("data"));
let other = Arc::clone(&value);
let h = thread::spawn(move || other.len());
println!("{} {}", value.len(), h.join().unwrap());

Код компилируется, но отравленный Mutex навсегда запрещает получить внутреннее значение. Значит, выполнение должно пройти через `std::sync::Arc` без изменения сигнатуры. Код компилируется: Arc позволяет двум потокам владеть одной неизменяемой String, а clone перемещает только атомарно учитываемый указатель. Код компилируется: Arc позволяет двум потокам владеть одной неизменяемой String, а clone копирует только атомарно учитываемый указатель. Код считается допустимым, потому что weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть. Компиляция завершится успешно: rc можно безопасно передавать между потоками, если изменяемые методы не вызываются.

Вопрос 4 из 25

Что нужно изменить вокруг `List::Cons`, чтобы устранить первопричину?

enum List { Cons(i32, Box<List>), Nil }
let list = List::Cons(1, Box::new(List::Nil));

Клонировать счётчик перед каждой операцией `List`, не устраняя цикл владения или конфликт динамического заимствования. Удерживать дополнительную сильную ссылку на данные этого фрагмента, чтобы объект не освобождался в проблемном месте `List`. Использовать Box для единственного владения данными в куче или рекурсивного поля; не применять его автоматически к каждому большому значению без измерения. Получать изменяемый доступ к данные этого фрагмента через сырой указатель внутри более широкого `unsafe` рядом с `List`, сохранив публичный безопасный метод. Заменить указатель вокруг `List` на `Arc` независимо от наличия потоков, не проверяя изменяемость и свойства данные этого фрагмента.

Вопрос 5 из 25

Какое изменение входа способно поменять вывод о механизме «Слабые ссылки Weak»?

Успешный Weak::upgrade в одном месте гарантирует существование владельца до конца функции без хранения Rc. Poison Mutex означает повреждение памяти, поэтому процесс обязан немедленно завершиться. Слабый счётчик может сохранять управляющий блок после Drop T, но обращаться к самому T уже нельзя; это различие важно при анализе памяти. Arc защищает внутреннее поле от гонок даже без Mutex или атомарных операций. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Контракт «Слабые ссылки Weak» считался бы одинаковым при любом состоянии входа. Drop последнего Rc всегда запускается в том же порядке, что создание всех клонов.

Вопрос 6 из 25

Где заканчивается гарантия обычного сценария для «Тестирование и инструменты Cargo»?

Если тест не вызвал panic RefCell, все возможные порядки заимствований безопасны. Цикл ссылок можно не проверять, когда программа завершается вскоре после его создания. Такое рассуждение переносило бы вывод о «Тестирование и инструменты Cargo» на неисполненную ветвь. Утечка памяти обычно не вызывает падения unit-теста; для циклов нужны структурные проверки, а для unsafe-взаимодействия — Miri или санитайзеры. Drop последнего Rc всегда запускается в том же порядке, что создание всех клонов. Поэтому ошибочный сценарий вокруг «Тестирование и инструменты Cargo» не проверяли бы отдельно. Poison Mutex означает повреждение памяти, поэтому процесс обязан немедленно завершиться. Тогда поведение «Тестирование и инструменты Cargo» при раннем выходе выводили бы из обычного пути.

Вопрос 7 из 25

Как следует интерпретировать результат проверки `weak_does_not_keep_value_alive`?

#[test]
fn weak_does_not_keep_value_alive() {
    use std::rc::Rc;
    let weak = {
        let value = Rc::new(String::from("x"));
        Rc::downgrade(&value)
    };
    assert!(weak.upgrade().is_none());
}

Фрагмент не соберётся: деструктор уменьшает счётчик ссылок. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Тест проверяет семантику владения по окончании области, а не только числовое значение счётчика внутри неё. Код компилируется, но weak::upgrade всегда возвращает Rc, пока существует сама Weak-ссылка. Компиляция закончится диагностикой: используется Weak для обратной ссылки. Rust примет этот код, поскольку weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть.

Вопрос 8 из 25

Какое утверждение о механизме «Потокобезопасный счётчик Arc» можно переносить на другие примеры?

Arc<T> является атомарным совместным владельцем; его Send и Sync зависят от свойств T и не превращают небезопасное внутреннее состояние в безопасное. Box обеспечивает совместное владение и клонируется без копирования T. Следовательно, поведение `std::sync::Arc` считалось бы одинаковым для всех допустимых типов. Weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть. Следовательно, для «Потокобезопасный счётчик Arc» не понадобилось бы явное предусловие. Rc можно безопасно передавать между потоками, если изменяемые методы не вызываются. Следовательно, поведение `std::sync::Arc` считалось бы одинаковым для всех допустимых типов. Arc делает внутренний T автоматически потокобезопасным независимо от Send и Sync.

Вопрос 9 из 25

Как изменить фрагмент с `std::sync::Arc`, чтобы дефект не повторился?

use std::sync::Arc;
use std::thread;
let value = Arc::new(String::from("data"));
let other = Arc::clone(&value);
let h = thread::spawn(move || other.len());
println!("{} {}", value.len(), h.join().unwrap());

Клонировать счётчик перед каждой операцией `std::sync::Arc`, не устраняя цикл владения или конфликт динамического заимствования. Заменить Arc на сырой указатель: атомарный счётчик нужен только для скорости, а не для владения. Интерфейс получает совместное владение или синхронизацию даже там, где исходная задача их не требовала. Заменить указатель вокруг `std::sync::Arc` на `Arc` независимо от наличия потоков, не проверяя изменяемость и свойства данные этого фрагмента. Получать изменяемый доступ к данные этого фрагмента через сырой указатель внутри более широкого `unsafe` рядом с `std::sync::Arc`, сохранив публичный безопасный метод. Использовать Arc для совместного владения между потоками; для мутации добавить подходящую синхронизацию, а не полагаться на Arc как на блокировку.

Вопрос 10 из 25

На какую часть контракта распространяется проверка `Rc::downgrade`?

let weak = Rc::downgrade(&root);
drop(root);
assert!(weak.upgrade().is_none());

Нормальный результат на одном входе позволяет распространить тот же вывод на отмену и частичное выполнение. Следовательно, для `upgrade` не понадобилось бы явное предусловие. После удаления сильного владельца upgrade сообщает None; безопасного доступа к уничтоженному Node нет. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Раз тест прошёл, производительность решения тоже можно считать подтверждённой.

Вопрос 11 из 25

Как проявится механизм «Счётчик ссылок Rc» при выполнении кода?

use std::rc::Rc;
let a = Rc::new(String::from("shared"));
let b = Rc::clone(&a);
println!("{}", Rc::strong_count(&a));
drop(b);
println!("{}", Rc::strong_count(&a));

Компиляция закончится диагностикой: деструктор уменьшает счётчик ссылок. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Код печатает 2, затем 1: Rc::clone увеличивает сильный счётчик и не клонирует саму String. Rust примет этот код, поскольку box автоматически создаёт совместное владение одним значением. Код печатает 2, затем 1: Arc::clone увеличивает сильный счётчик и не клонирует саму String. Компиляция завершится успешно: weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть.

Вопрос 12 из 25

Как следует интерпретировать результат проверки `std::rc::`?

use std::rc::{Rc, Weak};
let strong = Rc::new(5);
let weak: Weak<i32> = Rc::downgrade(&strong);
drop(strong);
assert!(weak.upgrade().is_none());

После исчезновения последнего сильного владельца Weak остаётся, но upgrade возвращает None и не оживляет значение. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `std::rc::` при таком толковании уже не требуется. Успешная ветвь служит достаточным доказательством поведения при ошибке и повторном выполнении. Такое рассуждение переносило бы вывод о `upgrade` на неисполненную ветвь.

Вопрос 13 из 25

Как завершится обычная ветвь выполнения после `List::Cons`?

enum List { Cons(i32, Box<List>), Nil }
let list = List::Cons(1, Box::new(List::Nil));

Rust примет этот код, поскольку box автоматически создаёт совместное владение одним значением. По этой логике отдельная проверка `List::Cons` на другом входе считалась бы лишней. Код компилируется, но отравленный Mutex навсегда запрещает получить внутреннее значение. Из этого следовало бы, что иной порядок операций для `List::Cons` ничего не меняет. Код компилируется, но конфликт RefCell автоматически ждёт освобождения предыдущего заимствования. В результате `List::Cons` считали бы безопасным и на путях, которых пример не выполняет. Сборка остановится: значение размещено в Box в куче. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Код компилируется: Box имеет известный размер указателя и разрывает бесконечную рекурсивную размерность enum.

Вопрос 14 из 25

Какое свойство «Слабые ссылки Weak» сохранится после небольшого рефакторинга?

Weak учитывается в strong_count и не даёт значению освободиться. Следовательно, поведение `std::rc::` считалось бы одинаковым для всех допустимых типов. Weak<T> не владеет значением и не удерживает T живым; upgrade возвращает Some(Rc/Arc) только при наличии сильного владельца. Weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть. Поэтому ошибочный сценарий вокруг «Слабые ссылки Weak» не проверяли бы отдельно. Box автоматически создаёт совместное владение одним значением. Поэтому ошибочный сценарий вокруг «Слабые ссылки Weak» не проверяли бы отдельно. Arc делает внутренний T автоматически потокобезопасным независимо от Send и Sync. Поэтому ошибочный сценарий вокруг «Слабые ссылки Weak» не проверяли бы отдельно.

Вопрос 15 из 25

Какой рефакторинг исправляет причину сбоя возле `weak_does_not_keep_value_alive`?

#[test]
fn weak_does_not_keep_value_alive() {
    use std::rc::Rc;
    let weak = {
        let value = Rc::new(String::from("x"));
        Rc::downgrade(&value)
    };
    assert!(weak.upgrade().is_none());
}

Клонировать счётчик перед каждой операцией `weak_does_not_keep_value_alive`, не устраняя цикл владения или конфликт динамического заимствования. Для умных указателей проверять Drop наблюдаемым сторожевым объектом, циклы, upgrade после удаления владельцев и отсутствие лишних сильных ссылок. Заменить указатель вокруг `weak_does_not_keep_value_alive` на `Arc` независимо от наличия потоков, не проверяя изменяемость и свойства данные этого фрагмента. Получать изменяемый доступ к данные этого фрагмента через сырой указатель внутри более широкого `unsafe` рядом с `weak_does_not_keep_value_alive`, сохранив публичный безопасный метод. Удерживать дополнительную сильную ссылку на данные этого фрагмента, чтобы объект не освобождался в проблемном месте `weak_does_not_keep_value_alive`.

Вопрос 16 из 25

Как устранить причину диагностики в строке с `std::rc::`?

use std::rc::{Rc, Weak};
struct Node { parent: Weak<Node> }
let root = Rc::new_cyclic(|me| Node { parent: me.clone() });
println!("{}", root.parent.upgrade().is_some());

Клонировать счётчик перед каждой операцией `std::rc`, не устраняя цикл владения или конфликт динамического заимствования. Использовать Weak для обратных связей и кэшей наблюдателей; каждый вызов upgrade обрабатывать как Option, потому что владелец мог исчезнуть. Удерживать дополнительную сильную ссылку на данные этого фрагмента, чтобы объект не освобождался в проблемном месте `std::rc`. Получать изменяемый доступ к данные этого фрагмента через сырой указатель внутри более широкого `unsafe` рядом с `std::rc`, сохранив публичный безопасный метод. Заменить указатель вокруг `std::rc` на `Arc` независимо от наличия потоков, не проверяя изменяемость и свойства данные этого фрагмента.

Вопрос 17 из 25

Какой узкий вывод следует из проверки `weak_does_not_keep_value_alive`?

#[test]
fn weak_does_not_keep_value_alive() {
    use std::rc::Rc;
    let weak = {
        let value = Rc::new(String::from("x"));
        Rc::downgrade(&value)
    };
    assert!(weak.upgrade().is_none());
}

# cargo test weak_does_not_keep_value_alive -- --nocapture

Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Успешная ветвь служит достаточным доказательством поведения при ошибке и повторном выполнении. Команда запускает конкретный тест; --nocapture позволяет увидеть диагностические сообщения Drop, если сторожевой тип их печатает. Раз тест прошёл, производительность решения тоже можно считать подтверждённой.

Вопрос 18 из 25

К какому результату приводит последовательность вокруг `std::rc::`?

use std::rc::{Rc, Weak};
struct Node { parent: Weak<Node> }
let root = Rc::new_cyclic(|me| Node { parent: me.clone() });
println!("{}", root.parent.upgrade().is_some());

Код компилируется, но weak::upgrade всегда возвращает Rc, пока существует сама Weak-ссылка. Из этого следовало бы, что иной порядок операций для `clone` ничего не меняет. Сборка пройдёт, поскольку weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть. Rust не примет такую запись, поскольку используется Weak для обратной ссылки. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Код печатает true, пока существует root: Weak не увеличивает сильный счётчик, но может временно получить Rc через upgrade. Код печатает true, пока существует root: Weak не увеличивает сильный счётчик, но может временно получить Arc через upgrade.

Вопрос 19 из 25

Какое правило связывает типы и наблюдаемое поведение в механизме «Тестирование и инструменты Cargo»?

Weak учитывается в strong_count и не даёт значению освободиться. Поэтому ошибочный сценарий вокруг «Тестирование и инструменты Cargo» не проверяли бы отдельно. Внутренняя изменяемость отменяет правило aliasing для создаваемых &mut ссылок. Тогда различия между обычным и граничным случаем для «Тестирование и инструменты Cargo» исчезли бы. Счётчики strong_count полезны в точечных тестах, но хрупки при рефакторинге; важнее проверять наблюдаемую жизнь ресурса и разрыв циклов. Циклы сильных ссылок Rc обнаруживаются и освобождаются стандартной библиотекой. Следовательно, для «Тестирование и инструменты Cargo» не понадобилось бы явное предусловие. Weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть. Следовательно, поведение `weak_does_not_keep_value_alive` считалось бы одинаковым для всех допустимых типов.

Вопрос 20 из 25

Какое свойство «Счётчик ссылок Rc» сохранится после небольшого рефакторинга?

Циклы сильных ссылок Rc обнаруживаются и освобождаются стандартной библиотекой. Проверку ошибки для «Счётчик ссылок Rc» при таком подходе заменили бы успешным примером. Box автоматически создаёт совместное владение одним значением. Поэтому ошибочный сценарий вокруг «Счётчик ссылок Rc» не проверяли бы отдельно. Weak поддерживает сильный счётчик и поэтому не позволяет владельцу исчезнуть. Из этого следовало бы, что иной порядок операций для «Счётчик ссылок Rc» ничего не меняет. Rc<T> предоставляет совместное владение без атомарного счётчика и поэтому сам по себе не предназначен для передачи между потоками. Box обеспечивает совместное владение и клонируется без копирования T. В результате «Счётчик ссылок Rc» считали бы безопасным и на путях, которых пример не выполняет.

Вопрос 21 из 25

Как изменить фрагмент с `std::rc::Rc`, чтобы дефект не повторился?

use std::rc::Rc;
let a = Rc::new(String::from("shared"));
let b = Rc::clone(&a);
println!("{}", Rc::strong_count(&a));
drop(b);
println!("{}", Rc::strong_count(&a));

Заменить Arc на сырой указатель: атомарный счётчик нужен только для скорости, а не для владения. Интерфейс получает совместное владение или синхронизацию даже там, где исходная задача их не требовала. Контракт `std::rc` считался бы одинаковым при любом состоянии входа. Клонировать счётчик перед каждой операцией `std::rc::Rc`, не устраняя цикл владения или конфликт динамического заимствования. Использовать Rc для совместного владения в одном потоке; изменение моделировать отдельно через Cell или RefCell только при ясном контракте. Заменить все владельцы на Rc<RefCell<_>>, включая данные, которые передаются между потоками. Интерфейс получает совместное владение или синхронизацию даже там, где исходная задача их не требовала. Тогда поведение `std::rc` при раннем выходе выводили бы из обычного пути. Заменить указатель вокруг `std::rc::Rc` на `Arc` независимо от наличия потоков, не проверяя изменяемость и свойства данные этого фрагмента.

Вопрос 22 из 25

Что устанавливает сценарий `Box::new` и где проходит граница его вывода?

let boxed = Box::new(String::from("x"));
let value: String = *boxed;
assert_eq!(value, "x");

Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Один положительный сценарий покрывает контракт целиком, включая частичный результат и преждевременное завершение. Контракт `Box::new` считался бы одинаковым при любом состоянии входа. Раз тест прошёл, производительность решения тоже можно считать подтверждённой. Разыменование Box по значению перемещает String из выделения; память Box затем освобождается корректно. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же.

Вопрос 23 из 25

Какой граничный случай важнее всего учесть для механизма «Потокобезопасный счётчик Arc»?

Boxed-значение нельзя переместить, потому что его данные находятся в куче. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Drop последнего Rc всегда запускается в том же порядке, что создание всех клонов. Проверку ошибки для «Потокобезопасный счётчик Arc» при таком подходе заменили бы успешным примером. Атомарный счётчик имеет стоимость; в однопоточном коде Rc дешевле, а частое клонирование Arc в горячем цикле стоит измерять. Poison Mutex означает повреждение памяти, поэтому процесс обязан немедленно завершиться. Arc защищает внутреннее поле от гонок даже без Mutex или атомарных операций. Такое рассуждение переносило бы вывод о «Потокобезопасный счётчик Arc» на неисполненную ветвь.

Вопрос 24 из 25

Где заканчивается гарантия обычного сценария для «Указатель Box»?

Box не даёт совместного владения и не делает внутреннее значение потокобезопасным; перемещение Box передаёт единственного владельца указателя. Boxed-значение нельзя переместить, потому что его данные находятся в куче. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Тогда поведение «Указатель Box» при раннем выходе выводили бы из обычного пути. Успешный Weak::upgrade в одном месте гарантирует существование владельца до конца функции без хранения Rc. Из этого следовало бы, что иной порядок операций для «Указатель Box» ничего не меняет. Arc защищает внутреннее поле от гонок даже без Mutex или атомарных операций. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Drop последнего Rc всегда запускается в том же порядке, что создание всех клонов. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Контракт «Указатель Box» считался бы одинаковым при любом состоянии входа.

Вопрос 25 из 25

Что устанавливает сценарий `std::sync::` и где проходит граница его вывода?

use std::sync::{Arc, Mutex};
let value = Arc::new(Mutex::new(1));
let v = Arc::clone(&value);
std::thread::spawn(move || *v.lock().unwrap() += 1).join().unwrap();
assert_eq!(*value.lock().unwrap(), 2);

Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `std::sync::` при таком толковании уже не требуется. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Такое рассуждение переносило бы вывод о `lock` на неисполненную ветвь. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Arc даёт владение между потоками, а Mutex отдельно обеспечивает исключительную мутацию значения. Один положительный сценарий покрывает контракт целиком, включая частичный результат и преждевременное завершение.