Кратко — по трём моделям: C (ручное управление, UB), Java (GC + проверки времени выполнения), Rust (владение/заимствования — проверка в компиляции). Ниже — ошибки, примеры и какие гарантии/издержки даёт каждая модель.

C — модель: ручное выделение/освобождение, указатели, нет проверок

Типичные ошибки: use-after-free, double-free, buffer overflow, dangling pointer, освобождение неинициализированной памяти, утечки памяти, неопределённое поведение (UB).

Пример (use-after-free + переполнение буфера):

#include <stdlib.h>
#include <string.h>
void vuln() {
char *p = malloc($10$); // выделили 10 байт
strcpy(p, "AAAAAAAAAAAAAAAA"); // переполнение буфера (buffer overflow)
free(p);
p[0] = 'B'; // use-after-free — UB
}Гарантии: практически никаких; язык даёт гибкость и минимальный runtime.Издержки: высокая вероятность уязвимостей безопасности и крашей; разработчик сам отвечает за корректность. Плюс: потенциально наилучшая производительность и предсказуемость памяти.

Java — модель: сборщик мусора + проверки времени выполнения

Что предотвращается: нет use-after-free/dangling pointer/double-free (GC контролирует время жизни), есть проверка выходов за границы массива (ArrayIndexOutOfBoundsException), строгая проверка типов во время загрузки классов и приведения (ClassCastException в проверяемых местах).Что остаётся возможным: утечки памяти через живые ссылки, NullPointerException, логические ошибки, некорректная синхронизация (data races при отсутствии синхронизации), уязвимости через JNI/native-код.Пример:
String[] a = new String[\(3)];
a[0] = "ok";
System.out.println(a[\(3)]); // выброс ArrayIndexOutOfBoundsException, а не UB

и GC:

Object o = new Object();
o = null; // объект станет кандидатом на сборку — нет use-after-freeГарантии: безопасность памяти (нет UB из-за освобождения), автоматическое управление временем жизни, типовая безопасность выше на уровне JVM.Издержки: runtime-накладные (heap, заголовки объектов), паузы/спайки GC (хоть современные GC минимизируют), дополнительные проверки (bounds checks) — JIT часто оптимизирует их, но некоторый overhead остаётся; меньше контроля над моментом освобождения (недетерминированный finalization).

Rust — модель: владение (ownership) + заимствования (borrowing) + проверка в компиляторе

Что предотвращается (в безопасном Rust): use-after-free, double-free, dangling pointers, data races (в многопоточной программе) — всё это либо компилятор запрещает, либо проверяется правилами владения/заимствования. Переполнение индекса при индексации среза вызывает паник (panic) в runtime, но не UB; в unsafe-блоках возможна небезопасность.Основные идеи: каждый объект имеет владельца; при передаче владения оригинал больше не доступен (move). Заимствования делятся на immutable (много) или единственное mutable; компилятор гарантирует отсутствие одновременных мутабельных и иммутабельных ссылок.

Примеры:

Move (предотвращает use-after-free):
fn main() {
let s = String::from("hello");
let s2 = s; // s перемещён в s2
println!("{}", s); // ошибка компиляции: use after move
}Заимствования (borrow checker):
fn f(x: &mut String) { x.push_str("!"); }

fn main() {
let mut s = String::from("hi");
let r1 = &s; // immutable borrow
let r2 = &s; // ещё один immutable — ОК
let r3 = &mut s; // ошибка: одновременно есть immutable borrows
}

- Безопасная индексация:

let v = vec![1, 2, 3];
let x = v[(5)]; // приводит к panic!, но не к UB

Гарантии: строгая безопасность памяти и потоковая безопасность в compile-time без GC; детерминированное освобождение (RAII/Drop), отсутствие runtime GC-пауз.Издержки: жёсткие правила (borrow checker) требуют иной стиль программирования, порождают сложность с жизненными циклами (lifetimes) и иногда необходимость использовать smart pointers (Rc/Arc, RefCell) для более гибного управления — они вносят runtime-накладные (счётчики ссылок, атомарные операции для Arc). Также частые компиляции и сложность unsafe-кода. Некоторый код становится более вербозным.

Короткое сравнение (гарантии vs издержки)

C: минимальные языковые гарантии, высокая скорость и контроль, но высокая вероятность UB и уязвимостей.Java: хорошие гарантии безопасности памяти за счёт GC и runtime-проверок; проще писать безопасный код, но есть runtime-накладные (память, GC, проверки) и неявное управление временем жизни.Rust: гарантии памяти и потоковой безопасности на этапе компиляции без GC; низкая runtime-накладная, детерминированное освобождение; издержки — сложность модели, необходимость часто менять дизайн (Rc/Arc/RefCell/unsafe) для гибкой архитектуры и более длительная компиляция.

Если нужно, могу привести ещё более конкретные минимальные примеры атак/исправлений или оценку накладных расходов (память/время) для каждой модели.