Чому короткий зміст повинен бути перетворений на int перед арифметичними операціями в C та C ++?

З відповідей, які я отримав на це запитання , виходить, що С ++ успадкував цю вимогу до перетворення shortв intпри виконанні арифметичних операцій від С. Чи можу я вибрати мозок, чому це було введено в С? Чому б просто не робити ці операції як short?

Наприклад ( взято з пропозиції dyp в коментарях ):

short s = 1, t = 2 ;
auto  x = s + t ;

xматиме тип int .

Якщо ми подивимося на обгрунтування міжнародного стандарту - Мови програмування - С у розділі 6.3.1.8 Звичайні арифметичні перетворення, то там сказано ( наголос на мене вперед ):

Правила стандарту для цих перетворень - це незначні модифікації правил у K&R: модифікації враховують додані типи та правила збереження вартості. Явна ліцензія була додана для виконання обчислень "ширшого" типу, ніж це було абсолютно необхідним, оскільки це може іноді створювати менший і швидший код, не кажучи вже про правильну відповідь частіше . Обчислення також можуть виконуватися в “вужчому” типі за правилом ніби до тих пір, поки буде отриманий однаковий кінцевий результат. Явне лиття завжди можна використовувати для отримання значення у бажаному типі

Розділ 6.3.1.8 із проекту стандарту C99 охоплює Звичайні арифметичні перетворення, які застосовуються до операндів арифметичних виразів, наприклад, розділ 6.5.6 Додаткові оператори говорять:

Якщо обидва операнди мають арифметичний тип, на них виконуються звичайні арифметичні перетворення .

Подібний текст ми знаходимо також у розділі 6.5.5 Мультиплікативні оператори . У випадку короткого операнда спочатку цілі числа підвищуються із розділу 6.3.1.1 Логічне, символи та цілі числа, де сказано:

Якщо int може представляти всі значення вихідного типу, значення перетворюється на int; в іншому випадку він перетворюється на беззнаковий int. Вони називаються цілочисельними акціями . ⁴⁸⁾ Усі інші типи не змінюються завдяки цілочисельним акціям.

Обговорення з розділу 6.3.1.1про Обгрунтування або міжнародного стандарту мов програмування-C на цілих заохочень насправді цікавіше, я буду вибірково цитатою б / с , що це занадто довго , щоб повністю процитувати:

Реалізація поділилася на два великі табори, які можна охарактеризувати як збереження без підпису та збереження цінності .

[...]

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

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

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

Це не особливість мови настільки, наскільки це обмеження архітектур фізичних процесорів, на яких працює код. intМашинка в C, як правило , розмір стандартного регістра процесора. Більше кремнію займає більше місця та більше енергії, тому в багатьох випадках арифметика може бути виконана лише на типах даних "природного розміру". Це не є загальним істинним, але більшість архітектур все ще мають це обмеження. Іншими словами, при додаванні двох 8-бітових чисел у процесорі насправді відбувається якийсь тип 32-бітової арифметики, за якою слідує або проста бітова маска, або інший відповідний тип перетворення.

shortі charтипи розглядаються стандартним сортом "типів зберігання", тобто піддіапазони, які ви можете використовувати для економії місця, але які не збираються купувати вам будь-яку швидкість, оскільки їх розмір "неприродний" для центрального процесора.

На деяких процесорах це не відповідає дійсності, але хороші компілятори досить розумні, щоб помітити, що якщо ви, наприклад, додаєте константу до непідписаного символу і зберігаєте результат назад у непідписаному символі, тоді немає необхідності проходити unsigned char -> intперетворення. Наприклад, з g ++ код, згенерований для внутрішнього циклу

void incbuf(unsigned char *buf, int size) {
    for (int i=0; i<size; i++) {
        buf[i] = buf[i] + 1;
    }
}

просто

.L3:
    addb    $1, (%rdi,%rax)
    addq    $1, %rax
    cmpl    %eax, %esi
    jg  .L3
.L1:

де ви можете побачити, що використовується вказівка ​​про додавання символів без знака ( addb).

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

Зв’язане питання, схоже, досить добре висвітлює його: центральний процесор просто ні. 32-розрядний процесор має власні арифметичні операції, налаштовані для 32-розрядних регістрів. Процесор воліє працювати у своєму улюбленому розмірі, і для таких операцій копіювання невеликого значення в регістр власного розміру є дешевим. (Для архітектури x86 32-розрядні регістри називаються так, ніби вони є розширеними версіями 16-розрядних регістрів ( eaxдо ax, ebxдо bxтощо); див. Цілочисельні інструкції x86 ).

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