> Там компилятор гарантирует выполнения некоторого количества просто элементарных правил

В этом и проблема! Ничего он не гарантирует!

Если бы он говорил "этот код некорректный!", следуй этим правилам - это было бы одно. А он говорит "я ни ... не понимаю что ты написал, пиши как я сказал" и просто ОТБРАСЫВАЕТ корректный валидный безопасный код 😆 Это бреееед, ребята 🤠

Это не то что ожидаешь от СИСТЕМНОГО языка программирования.

Те он тупо слабенький и не понимает что ты пишешь. Это как если бы компилятор говорил что "многопоточная программа" небезопасна, пиши в один поток!

А почему бы и нет, а действительно супербезопасно!

> типа не меняй переменную с двух разных мест просто так

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

И когда я пишу базу данных, я делаю вещи посложнее чем "отслеживание ссылок" на несколько порядков 😆 Если бы был простоое переключение safe / unsafe вопросов бы не было. Там вообще всё начинает разваливаться, какие-то pin, transmute ещё какая-то бредятина появляется.

> И встречный вопрос - раз для раста это проблема, а зиг круче раста, то зиг 146% поборол дедлоки и другие проблемы многопоточного кода? Правда ведь?))

Ты не понял мой point. Zig - это системный язык программирования, он тебе позволяет легко сделать всё что угодно, но ЯВНО. И максимально удобно и безопасно там, где это оправдано.

Какой смысл усложнять очень сильно язык и при этом не решить основные и главные проблемы "безопасной работы памяти"?) Ты сравни код Zig и Rust на досуге. Zig читается как песня, он ПОНЯТЕН. Он делает то, что ты ожидаешь от языка и что видишь в коде.

При этом Zig БОЛЕЕ безопасный при работе с памятью. Он отлавливает всё что возможно отловить существующими средствами вообще без изменений языка.

Например, ты просто передаешь std.testing.allocator (специальный аллокатор, который отлавливает утечки памяти, аналог Valgrind) в структуру и ВСЕ вызовы всей программы будут использовать этот аллокатор. Или передаешь его только в нужный кусок кода. Неплохо иметь "Valgrind" из коробки в языке, согласись? Который вызывается одной строчкой.

Это отлавливает 99.99% ошибок с памятью на этапе первых запусков программы (даже на тестах). В runtime, ведь в compile time можно выловить только очень ограниченное количество ошибок, и все они банальные (простые).

Я несколько месяцев (когда не знал как собирать сложное приложение с их билд системой, незрелая она была тогда) писал приложение только на тестах и этом аллокаторе))) Собрал - заработало сразу.

Твой "безопасный Rust" так умеет?) Нет) Только не говори что "и таааак сойдёт" или "не очень то и нужно было". В Rust любая функция может неявно вызвать глобальный аллокатор. А может вызвать переданный как параметр (если есть такая опция), а может и тот и другой.

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

А планирует задействовать вообще все санитайзеры которые там есть, но руки не дошли. В том числе и ThreadSanitaizer. Это гораздо круче чем все твои проверки в Rust.

Вот их документации Zig что он УЖЕ умеет:

Reaching Unreachable Code
Index out of Bounds
Cast Negative Number to Unsigned Integer (пофиксили в Rust в 2015)
Cast Truncates Data
Integer Overflow
Exact Left Shift Overflow
Exact Right Shift Overflow
Division by Zero
Remainder Division by Zero
Exact Division Remainder
Attempt to Unwrap Null
Attempt to Unwrap Error
Invalid Error Code
Invalid Enum Cast
Invalid Error Set Cast
Incorrect Pointer Alignment (!!!) (а Rust схавает и не подавится и привет Segmentation Fault в лучшем случае, в худшем "безопасное" перезаписыаание области памяти)
Wrong Union Field Access
Out of Bounds Float to Integer Cast (!!! Читаем - https://stackoverflow.com/questions/61144957/what-happens-wh...

In Rust 1.44 and earlier, if you use as to cast a floating-point number to an integer type and the floating-point number does not fit¹ in the target type, the result is an undefined value², and most things that you can do with it cause undefined behavior !!!

Очень "безопасно" для языка версии 1.44. Сравни с версией Zig 0.11 😆)

Pointer Cast Invalid Null (В zig есть null safety, чего дарт не мог получить вплоть до версии Dart 3.0 - указатели НЕ МОГУТ быть нулевыми)

Многие проверки СРАЗУ делаются и в compile time (условия которые можно проверить во время компиляции), и в runtime!

Твой "безопасный" Rust так умеет?

> Нужно *всего лишь* деаллоцировать память в нужный момент и строго только один раз.

Нет, выше я писал. Это делает КОМПИЛЯТОР. Это в С ты должен во всех return освободить всю память и ничего не забыть и помнить кто где аллоцировано, а что ещё нет.

Ты должен написать только defer allocator.free(memory) И ВСЁ. Компилятор сам вызовет освобождение памяти ВО всех точках выхода из функции!

А как в Rust НЕ вызывать деструктор? Например у меня есть память, я туда пишу и знаю что если я возвращаю ошибку, дальше в коде она полностью будет перезаписана другими данными! Мне не нужно её тут обнулять (в других местах нужно).

А, нельзя?)))

> Но вот почему-то ни один сишник еще не справился с такой элементарной задачей

Потому что в С ты должен освобождать ресурсы во всех разных сложных точках выхода из функции.

И там могут быть сложные условия - array1 уже выделился, array2 тоже, а на array3 память выделить не получилось - освобождаем array1 и array2. А в других случаях нужно освобождать только array1 (валимся на выделении array2) и так далее.

Код получается очень сложным, громоздким. Легко ошибиться. И код получается нелинейным.

> Ну и так далее продолжаем выходить за пределы массива, писать что угодно куда угодно и ловить RCE.

Ответил выше. Ни за какие пределы ты не выйдешь никуда.