Чому "void *" неявно не введено в C ++?

У C немає необхідності призначати void *будь-який інший тип вказівника, він завжди безпечно просувається. Однак у C ++ це не так. Наприклад,

int *a = malloc(sizeof(int));

працює в C, але не в C ++. (Примітка. Я знаю, що ви не повинні використовувати mallocв C ++, або в цьому питанні new, і натомість слід віддавати перевагу розумним покажчикам та / або STL; це запитується з цікавості) Чому стандарт C ++ не дозволяє це неявне відтворення, в той час як стандарт C робить?

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

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

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

Ви можете запитати, як це дружньо, коли воно насправді вимагає від вас більше вводити текст.

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

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

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

Ось що говорить Stroustrup :

У C ви можете неявно перетворити порожнечу * в T *. Це небезпечно

Потім він показує приклад того, як пустота * може бути небезпечною і каже:

... Отже, в C ++, щоб отримати T * від порожнечі *, вам потрібно чіткий склад. ...

Нарешті, він зазначає:

Одне з найпоширеніших застосувань цього небезпечного перетворення в C - це присвоєння результату malloc () відповідному вказівнику. Наприклад:

int * p = malloc (sizeof (int));

В C ++ використовуйте новий оператор typesafe:

int * p = новий int;

Він детальніше описує це питання в «Дизайні та еволюції C ++» .

Отже, відповідь зводиться до: Мовний дизайнер вважає, що це небезпечний зразок, і тому зробив це незаконним і надав альтернативні способи досягнення того, для чого зазвичай використовується цей шаблон.

У C немає необхідності призначати порожнечу * до будь-якого іншого типу вказівника, це завжди безпечно просувається.

Це завжди рекламується, так, але навряд чи безпечно .

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

Розглянемо загалом ці 3 підходи до перетворення типів:

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

Що ж, 1 - це некрасиво і є практичною перешкодою для того, щоб зробити що-небудь зроблене, але може бути справді використаний там, де потрібна велика обережність. Приблизно C вибрано 2, що легше здійснити, і C ++ для 3, що важче реалізувати, але безпечніше.

За визначенням, недійсний вказівник може вказувати на що завгодно. Будь-який вказівник може бути перетворений на недійсний вказівник, і, таким чином, ви зможете конвертувати назад, отримуючи точно таке ж значення. Однак вказівники на інші типи можуть мати такі обмеження, як обмеження вирівнювання. Наприклад, уявіть собі архітектуру, де символи можуть займати будь-яку адресу пам’яті, але цілі числа повинні починатися з рівних меж адреси. У певних архітектурах цілі вказівники можуть навіть нараховувати одночасно 16, 32 або 64 біти, так що char * може насправді мати кратне числове значення int *, вказуючи на одне місце в пам'яті. У цьому випадку перетворення з пустоти * фактично закругляє біти, які неможливо відновити і тому не є оборотними.

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