Почему в Java и C# есть операторы битового сдвига?

Вы правы, если операторы сдвига используются только как альтернатива умножениям, это следует оставить на усмотрение компилятора.

Я полагаю, вы пропустили такие приложения, как:

• Шифрование/дешифрование
• Расчет CRC
• Манипуляции с растровыми изображениями (графика, блокировки базы данных)
• Сжатие/декомпрессия
• Настройка данных для аппаратных регистров
• Изменить кодировку

и многое другое нуждается в битовом повороте для эффективной реализации без собственного кода.

Первая причина:

Иногда — в большинстве случаев — вы хотите обрабатывать целое число как число. Иногда целое число является удобным способом представления набора битов.

Умножение — это операция над числами.

Сдвиг — это операция над набором битов.

То, что существует связь между результатами умножения и результатами сдвига, не имеет особого значения. Операции логически отличаются.

Вторая причина:

C# и Java были разработаны, чтобы быть знакомыми разработчикам C, хотя и на поверхностном уровне. Поэтому общие идиомы из C были включены в C# и Java.

Если бы я хотел умножить число на 4, я бы написал * 4. Если бы я намеревался сдвинуть некоторые биты влево на 2 позиции, я бы написал << 2.

Повторный вопрос:

Почему в Java и C# есть операторы битового сдвига?

Я много работаю с двоичными данными, где я не думаю о целых числах и т. д. — только двоичные — и в этой области совершенно логично постоянно использовать операторы сдвига. .

Конечно, я мог бы ввести * 2 и т. д., но на самом деле я хочу сдвинуть биты.

Это распространено в ряде областей, где важны байты (например, графическое программирование, сериализация и т. д.).

Кроме того, существуют некоторые тонкости операций сдвига, когда вы не хотите вести себя как целое число, в частности при работе с ребрами... происходит, когда вы немного смещаете карту влево или смещаете вправо биты вглубь карты (-ve против +ve и т. д.) хорошо понятны, но критичны. Точно так же поведение целочисленного умножения checked/unckecked иногда очень важно.

Вы спрашиваете не о том, почему в С#/Java есть операторы битового сдвига, а о том, почему компилятор javac не оптимизирует умножения и деления со степенью двойки в битовые сдвиги.

Рефлекторная реакция на это заключается в том, что умножение и деление имеют другую семантику, чем битовые сдвиги, поэтому они не отображают 100% замену операций.

Кроме того, вы забыли дополнительный шаг компиляции, который происходит в JIT (HotSpot), где происходят всевозможные дополнительные оптимизации. Откровенно говоря, нет необходимости оптимизировать этот конкретный шаг, в отличие от C, где код находится в том виде, в каком его генерирует компилятор.

Потому что разработчики языка подумали, что было бы неплохо их иметь.

На самом деле не важно, что они эквивалентны какой-то другой операции и что компиляторы достаточно умны, чтобы эффективно реализовать операции. Если это то, к чему мы идем, то вам не нужно ничего, кроме ассемблера макросов и действительно хорошего оптимизатора времени компоновки, возможно, на виртуальной машине со сборщиком мусора. Это не те цели, которые обычно преследуют разработчики языков.

Например, ваша программа может использовать что-то вроде битовых масок. В этом случае операция битового сдвига является необходимостью. Или если вы просто решаете какую-то странную задачу, требующую кодирования состояний определенным образом.

Посмотрите этот учебник – большинство примеров взяты из математических задач. Если вы просто делаете сайт или приложение с графическим интерфейсом, вам, вероятно, не нужно переключаться, но иногда вам действительно нужно...

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

Так что вы можете сдвигать биты влево и вправо. Что вы хотите, чтобы эти биты и их операции сдвига представляли, полностью зависит от вас.