Чому у C ++ є "невизначена поведінка" (UB), а інші мови, такі як C # або Java, не мають?

Цей пост переповнення стеку містить досить вичерпний перелік ситуацій, коли специфікація мови C / C ++ заявляється як "невизначена поведінка". Однак я хочу зрозуміти, чому інші сучасні мови, такі як C # або Java, не мають поняття "невизначена поведінка". Це означає, що дизайнер компілятора може керувати всіма можливими сценаріями (C # і Java) чи ні (C і C ++)?

Не визначена поведінка - одна з тих речей, які були визнані дуже поганою ідеєю лише в ретроспективі.

Перші компілятори були великими досягненнями і весело вітали вдосконалення в порівнянні з альтернативою - машинною мовою або мовою програмування мов. Проблеми з цим були добре відомі, а мови високого рівня були винайдені спеціально для вирішення цих відомих проблем. (Ентузіазм в той час був настільки великим, що HLL колись називались "кінцем програмування" - начебто відтепер нам доведеться лише тривіально записати те, що ми хотіли, і компілятор зробив би всю справжню роботу.)

Лише пізніше ми зрозуміли, що нові проблеми виникають із новим підходом. Будучи віддаленим від фактичної машини, на якій працює код, означає більше можливостей, щоб речі мовчки не робили те, що ми очікували від них. Наприклад, виділення змінної зазвичай залишає невизначеним початкове значення; це не вважалося проблемою, тому що ви б не виділили змінну, якби не хотіли утримувати в ній значення, правда? Напевно, було не надто сподіватися, що професійні програмісти не забудуть призначити початкове значення, чи не так?

Виявилося, що з більшими кодовими базами та складнішими структурами, які стали можливими завдяки більш потужним системам програмування, так, багато програмістів час від часу дійсно здійснювали б подібні огляди, і невизначена поведінка внаслідок цього стала головною проблемою. Навіть сьогодні більшість витоків безпеки від крихітних до жахливих є результатом невизначеної поведінки в тій чи іншій формі. (Причина полягає в тому, що зазвичай невизначена поведінка насправді дуже визначається речами на наступному нижчому рівні з обчислень, і зловмисники, які розуміють цей рівень, можуть використовувати цю кімнату для виправлення, щоб створити програму не тільки непередбачуваних речей, а саме тих, що речей вони мають намір.)

Оскільки ми визнали це, було загальне прагнення вигнати невизначене поведінку з мов високого рівня, і Java особливо ретельно ставився до цього (що було порівняно просто, оскільки він так чи інакше був розроблений на власній спеціально розробленій віртуальній машині). Старі мови, такі як C, не можуть бути легко впорядковані таким чином, не втрачаючи сумісності з величезною кількістю існуючого коду.

Редагувати: Як вказувалося, ефективність - ще одна причина. Невизначена поведінка означає, що автори-компілятори мають багато вільного простору для використання цільової архітектури, так що кожна реалізація відходить від якнайшвидшого виконання кожної функції. Це було важливішим для вчорашніх недостатніх машин, ніж сьогодні, коли зарплата програміста часто є вузьким місцем для розробки програмного забезпечення.

В основному тому, що дизайнери Java та подібних мов не хотіли, щоб їхня мова була не визначеною. Це було компромісом - якщо невизначена поведінка має потенціал для підвищення продуктивності, але мовні дизайнери визначили пріоритетність безпеки та передбачуваності вище.

Наприклад, якщо ви виділите масив у C, дані не визначені. У Java всі байти повинні бути ініціалізовані до 0 (або якогось іншого заданого значення). Це означає, що час виконання повинен пройти над масивом (операція O (n)), тоді як C може виконати розподіл за мить. Тож C завжди буде швидшим для таких операцій.

Якщо код, що використовує масив, все-таки заповнить його перед читанням, це в основному витрачає зусилля на Java. Але в тому випадку, коли код читається спочатку, ви отримуєте передбачувані результати на Java, але непередбачувані результати в C.

Невизначена поведінка забезпечує значну оптимізацію, надаючи компілятору широту робити щось дивне або несподіване (або навіть нормальне) за певних граничних чи інших умов.

Дивіться http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html

Використання неініціалізованої змінної: Це загальновідоме джерело проблем у програмах С, і існує багато інструментів для їх усунення: від попереджень компілятора до статичних та динамічних аналізаторів. Це покращує продуктивність, не вимагаючи, щоб всі змінні були ініціалізовані нулем, коли вони потрапляють у область (як це робить Java). Для більшості скалярних змінних це може спричинити невеликі накладні витрати, але масиви стеків та пам'ять malloc'd спричинить запам'ятовувальний набір, що може бути досить дорогим, тим більше, що накопичувач зазвичай повністю перезаписаний.

Переповнене ціле число переповнення: Якщо арифметика типу "int" (наприклад) переповнюється, результат не визначений. Одним із прикладів є те, що "INT_MAX + 1" не гарантується як INT_MIN. Така поведінка дозволяє певні класи оптимізацій, важливі для деякого коду. Наприклад, знання того, що INT_MAX + 1 не визначено, дозволяє оптимізувати "X + 1> X" до "true". Знання множення "не може" переповнювати (тому що це буде невизначено) дозволяє оптимізувати "X * 2/2" до "X". Хоча це може здатися тривіальним, такі речі зазвичай піддаються вбудованому вбудованому макросу і розширенню макросів. Більш важлива оптимізація, що це дозволяє, - це петлі "<=", як це:

for (i = 0; i <= N; ++i) { ... }

У цьому циклі компілятор може припустити, що цикл буде повторювати рівно N + 1 раз, якщо значення "i" не визначено при переповненні, що дає змогу розпочати широкий діапазон оптимізацій циклу. З іншого боку, якщо змінна визначена для завершити переповнення, тоді компілятор повинен припустити, що цикл, можливо, нескінченний (що відбувається, якщо N - INT_MAX) - що потім вимикає ці важливі оптимізації циклу. Особливо це стосується 64-бітних платформ, оскільки стільки код використовує "int", як індукційні змінні.

У перші дні С було багато хаосу. Різні укладачі по-різному ставилися до мови. Коли з'явився інтерес написати специфікацію для цієї мови, ця специфікація повинна бути досить сумісною в порівнянні з C, на яку програмісти покладаються зі своїми компіляторами. Але деякі з цих деталей не є портативними і взагалі не мають сенсу, наприклад, якщо припустити певну цінність чи макет даних. Таким чином, стандарт C залишає багато деталей як невизначене або визначене для виконання поведінка, що залишає багато гнучкості для авторів-компіляторів. C ++ ґрунтується на C, а також відрізняється невизначеним поведінкою.

Java намагалася бути набагато безпечнішою та значно простішою мовою, ніж C ++. Java визначає семантику мови з точки зору ретельної віртуальної машини. Це залишає мало місця для невизначеної поведінки, з іншого боку, це робить вимоги, які можуть бути складними для виконання Java (наприклад, що довідкові завдання повинні бути атомними, або як цілі числа працюють). Там, де Java підтримує потенційно небезпечні операції, їх зазвичай перевіряє віртуальна машина під час виконання (наприклад, деякі касти).

Мови JVM та .NET легко:

1. Вони не повинні мати можливість безпосередньо працювати з обладнанням.
2. Вони повинні працювати лише з сучасними настільними та серверними системами або з досить подібними пристроями, або принаймні пристроями, призначеними для них.
3. Вони можуть накладати сміття для всієї пам'яті та примусової ініціалізації, отримуючи таким чином безпеку покажчиків.
4. Їх уточнив один актор, який також забезпечив остаточну реалізацію.
5. Вони можуть вибрати безпеку над продуктивністю.

Хоча для вибору є хороші моменти:

1. Системне програмування - це зовсім інша кульова гра, і безкомпромісна оптимізація для програмування додатків є розумною.
2. Правда, весь час є менш екзотичне обладнання, але тут залишаються невеликі вбудовані системи.
3. GC погано підходить для негорючих ресурсів і торгує набагато більше місця для хорошої роботи. І більшість (але не майже всі) примусових ініціалізацій можна оптимізувати.
4. Переваги є більшою конкуренцією, але комітети означають компроміс.
5. Всі ці кордони провер дійсно складаються, хоча більшість з них може бути оптимізовано геть. Перевірка нульових покажчиків в основному може бути здійснена шляхом лову доступу до нуля накладних витрат завдяки віртуальному адресному простору, хоча оптимізація все ще гальмується.

Там, де надаються люки для евакуації, ті запрошують повноцінного невизначеного поведінки ще. Але принаймні вони, як правило, використовуються лише в декількох дуже коротких розтяжках, які легше перевірити вручну.

Java та C # характеризуються домінуючим постачальником, принаймні на початку свого розвитку. (Sun та Microsoft відповідно). C і C ++ різні; вони мали кілька конкуруючих реалізацій з самого початку. Особливо C працював і на екзотичних апаратних платформах. Як результат, між реалізаціями виникла різниця. Комітети ISO, які стандартизували C та C ++, могли домовитись про великий загальний знаменник, але в тих краях, де імплементація відрізняється, стандарти залишають місце для впровадження.

Це пояснюється тим, що вибір апаратної поведінки може бути дорогим для апаратних архітектур, які є упередженими до іншого вибору - очевидний вибір.

Справжня причина зводиться до принципової різниці у намірах між C та C ++ з одного боку, та Java та C # (лише для кількох прикладів) з іншого. З історичних причин велика частина дискусій тут стосується C, а не C ++, але (як ви, мабуть, уже знаєте), C ++ є досить прямим нащадком C, тому те, що він говорить про C, стосується C ++.

Хоча вони значною мірою забуті (а їх існування іноді навіть заперечується), перші перші версії UNIX були написані мовою асемблерів. Значна частина (якщо не виключно) оригінальної цілі C була портом UNIX з мови асемблера на мову вищого рівня. Частина наміру полягала в тому, щоб написати якомога більше операційної системи мовою вищого рівня - або дивитись на це з іншого напрямку, щоб мінімізувати кількість, яку потрібно було написати мовою асемблера.

Для цього C потрібно було забезпечити майже той самий рівень доступу до обладнання, що і мова монтажу. PDP-11 (для прикладу) відображає регістри вводу / виводу за конкретними адресами. Наприклад, ви прочитали одне місце пам'яті, щоб перевірити, чи була натиснута клавіша на системній консолі. Один біт був встановлений у тому місці, коли були дані, які очікують на читання. Потім ви прочитали байт з іншого вказаного місця, щоб отримати код ASCII натиснутої клавіші.

Так само, якби ви хотіли надрукувати деякі дані, ви перевірили б інше вказане місце, і коли пристрій виводу буде готовий, ви записуєте свої дані в інше вказане місце.

Для підтримки драйверів запису для таких пристроїв, C дозволив вам вказати довільне розташування за допомогою певного цілого типу, перетворити його на покажчик та прочитати чи записати це місце в пам'яті.

Звичайно, це має досить серйозну проблему: не кожна машина на землі має пам'ять, викладену ідентично PDP-11 з початку 1970-х. Отже, коли ви берете це ціле число, перетворюєте його на покажчик, а потім читаєте чи записуєте через цей вказівник, ніхто не може надати будь-якої розумної гарантії того, що ви збираєтеся отримати. Просто для наочного прикладу читання та запис може відображати окремі регістри в апараті, тож ви (всупереч нормальній пам'яті) якщо щось пишете, то спробуйте прочитати його назад, те, що ви прочитали, може не відповідати тому, що ви написали.

Я бачу кілька можливостей, які залишає:

1. Визначте інтерфейс для всіх можливих апаратних засобів - вкажіть абсолютні адреси всіх місць, які ви хочете прочитати чи написати, щоб взаємодіяти з обладнанням будь-яким способом.
2. Заборонити цей рівень доступу та постановити, що кожен, хто хоче робити такі речі, повинен використовувати мову мовлення.
3. Дозвольте людям це робити, але залиште їх, щоб вони прочитали (наприклад) посібники для обладнання, на яке вони орієнтуються, і написати код, щоб він відповідав обладнанням, яке вони використовують.

З них 1 здається досить безглуздим, що навряд чи варто додаткового обговорення. 2 в основному викидає основний намір мови. Це залишає третій варіант по суті єдиним, який вони могли б розумно розглянути взагалі.

Ще один момент, який виникає досить часто - це розміри цілих чисел. C займає "положення", яке intмає бути природним розміром, запропонованим архітектурою. Отже, якщо я програмую 32-бітний VAX, intмабуть, це буде 32 біти, але якщо я програмую 36-бітний Univac, intмабуть, це буде 36 біт (і так далі). Мабуть, не розумно (а це навіть не можливо) писати операційну систему для 36-бітного комп'ютера, використовуючи лише типи, які гарантовано мають кратні розміри 8 біт. Можливо, я просто поверхневий, але мені здається, що якби я писав ОС для 36-бітної машини, я, мабуть, хотів би використовувати мову, яка підтримує 36-бітний тип.

З мовної точки зору, це призводить до ще більш невизначеної поведінки. Якщо я візьму найбільше значення, яке вміститься у 32 біти, що буде, коли я додаю 1? У типовому 32-бітному апаратному забезпеченні він перекинеться (або, можливо, викине якусь технічну несправність). З іншого боку, якщо він працює на 36-бітному апаратному забезпеченні, він просто ... додасть його. Якщо мова буде підтримувати операційну систему написання, ви не можете гарантувати жодної поведінки - ви просто повинні дозволити як розміри типів, так і поведінку переповнення змінюватися залежно від одного.

Java та C # можуть ігнорувати все це. Вони не призначені для підтримки операційних систем запису. З ними у вас є пара варіантів. Одне полягає в тому, щоб апаратне забезпечення підтримувало те, чого вони вимагають - оскільки вони вимагають типів 8, 16, 32 та 64 біт, просто будуйте апаратне забезпечення, яке підтримує ці розміри. Інша очевидна можливість полягає в тому, щоб мова працювала лише над іншим програмним забезпеченням, яке забезпечує навколишнє середовище, яке вони хочуть, незалежно від того, що може хотіти базове обладнання.

У більшості випадків це насправді не вибір або вибір. Швидше за все, багато реалізацій трохи роблять і те, і інше. Ви зазвичай запускаєте Java на JVM, що працює в операційній системі. Найчастіше ОС записується на С, а JVM - на C ++. Якщо JVM працює на процесорі ARM, дуже ймовірно, що процесор включає в себе розширення Jazelle ARM для більш детального адаптації обладнання до потреб Java, тому менше потрібно робити програмне забезпечення, а код Java працює швидше (або менше) повільно, все одно).

Підсумок

C і C ++ мають невизначену поведінку, оскільки ніхто не визначив прийнятну альтернативу, яка дозволяє їм робити те, що їм призначено. C # і Java застосовують інший підхід, але такий підхід погано (якщо він взагалі відповідає) цілям C і C ++. Зокрема, не здається, що це забезпечує розумний спосіб запису системного програмного забезпечення (наприклад, операційної системи) на більшість довільно вибраних апаратних засобів. Обидва зазвичай залежать від можливостей, які надає існуюче системне програмне забезпечення (як правило, написане на C або C ++) для виконання своїх завдань.

Автори стандарту C очікували, що читачі визнають те, що вони вважають очевидним, і на це натякали у опублікованому Обґрунтуванні, але не сказали прямо: Комітету не потрібно було замовляти авторів-компіляторів для задоволення потреб своїх клієнтів, оскільки клієнти повинні краще, ніж Комітет, знати, які їх потреби. Якщо очевидно, що очікується, що компілятори для певних видів платформ оброблять конструкцію певним чином, нікому не слід хвилюватись, чи говорить Стандарт, що конструкція викликає не визначене поведінку. Невдача стандарту наказувати, що відповідні компілятори корисно обробляють фрагмент коду, жодним чином не означає, що програмісти повинні бути готові купувати компілятори, які цього не роблять.

Такий підхід до мовного дизайну дуже добре працює у світі, де авторам-укладачам потрібно продавати свої товари платним клієнтам. Він повністю розпадається у світі, де автори-компілятори відокремлені від ефектів ринку. Сумнівно, що правильні ринкові умови коли-небудь існуватимуть для того, щоб керувати мовою так, як вони керували тією, яка стала популярною у 90-х роках, і ще сумнівніше, що будь-який здоровий мовний дизайнер захоче покластися на такі ринкові умови.

У обох C ++ і c є описові стандарти (у будь-якому разі версії ISO).

Які існують лише для пояснення того, як працюють мови, та надання єдиної довідки про те, що це за мова. Зазвичай постачальники компіляторів та бібліотечні автори лідирують, а деякі пропозиції включаються до основного стандарту ISO.

Java та C # (або Visual C #, на який я маю на увазі) мають приписи . Вони розповідають, що в мові остаточно випереджає час, як це працює та що вважається дозволеною поведінкою.

Більш важливо, ніж це, Java насправді має "опорну реалізацію" у Open-JDK. (Я думаю, що Рослін вважається реалізацією посилань Visual C #, але не зміг знайти джерело для цього.)

У випадку Java, якщо в стандарті є якась неоднозначність, а Open-JDK робить це певним чином. Те, як це робить Open-JDK - це стандарт.

Невизначена поведінка дозволяє компілятору генерувати дуже ефективний код для різних архітекторів. У відповіді Еріка згадується оптимізація, але це виходить за рамки цього.

Наприклад, підписані переповнення є невизначеною поведінкою в C. На практиці, компілятор повинен був створити простий код підпису додавання для виконання центрального процесора, і така поведінка буде будь-якою, що робив конкретний процесор.

Це дозволило C працювати дуже добре і створювати дуже компактний код для більшості архітектур. Якби стандарт вказав, що підписані цілі числа повинні переповнюватися певним чином, тоді для центральних процесорів, які поводилися по-різному, знадобилося б набагато більше генерування коду для простого підписаного додавання.

Це причина більшої частини невизначеної поведінки в С, і чому речі типу розміру intрізняться між системами. Intзалежить від архітектури , і як правило , вибирають так, щоб бути найшвидшим, найбільш ефективним типом даних , які більше , ніж char.

Ще коли було новим, ці міркування були важливими. Комп'ютери були менш потужними, часто мали обмежену швидкість обробки та пам'ять. C використовувався там, де продуктивність справді мала значення, і від розробників, як очікували, зрозуміли, наскільки комп'ютери працюють досить добре, щоб знати, що насправді буде визначати ці не визначені форми поведінки в їх конкретних системах.

Пізніші мови, такі як Java та C #, віддають перевагу виключенню невизначеної поведінки над необробленою продуктивністю.

У певному сенсі у неї також є Java. Припустимо, ви дали неправильний компаратор для Arrays.sort. Він може кинути виняток, коли він його виявляє. В іншому випадку він буде сортувати масив певним чином, який не гарантовано буде будь-яким конкретним.

Аналогічно, якщо ви змінюєте змінну з декількох потоків, результати також непередбачувані.

C ++ просто пішов далі, щоб створити більше невизначених ситуацій (а точніше, Java вирішила визначити більше операцій) і мати ім’я для цього.