ошибка overflow

[Хакер]

Ты прикалываешься, или действительно считаешь, что unsigned и int — это два разных типа, а не тип и просто-модификатор, который можно приписать к любому целочисленному типу?

[Qwertiy]

Знаковое и беззнаковое расширение - вещи разные. И выводимый результат разный.

[Хакер]

Ох. Я не знаю, зачем ты это пишешь.
Суть такова.
Майкл пишет о нелогичности того, что 8000 типа signed int16 оказывается не равно значению 8000 типа signed int32.
Я одним постом описал, почему это логично. Другим постом привёл пример аналогичного сравнения на Си.

Просто у меня две строчки кода на разных языках аналогичны, если и там и там речь идёт об одних и тех же типах (причём не по названию типа, а по сути типа) и одних и тех же константах.
А у тебя две строчки кода аналогичны, если чисто-внешне они похоже.

Для тебя аналог VB-шного кода &h8000& = &h8000 будет такой: 0x8000L == 0x8000, потому что для тебя важно точное соответствие TDC и типоописывающего суффикса.

Для меня аналог VB-шного кода &h8000& = &h8000 будет такой: (int)0x8000 == (short)0x8000, потому что для меня важно, чтобы типы сравниваемых значений были идентичны (по разрядности и знаковости).

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

[Qwertiy]

Берём 16-разрядный Borland C++ 3.1 b компилируем в нём

Код: Выделить всё

#include <stdio.h>

int main(void)
  {
  puts(0x8000L==0x8000 ? "YES" : "NO");
  puts(0x8000L==0x8000D ? "YES" : "NO");
  return 0;
  }

Получаем

Код: Выделить всё

YES
NO

Теперь сравниваем код с VB:
0x8000L==0x8000 <=> &H8000&=&H8000
0x8000L==0x8000D <=> &H8000&=&H8000%
Так почему же ты настаиваешь, что разницы нет?

[Qwertiy]

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

Как раз наоборот. Вот исходный вопрос:

А разве не должно? Два сравниваются два одинаковых значения в итоге должно быть True. Даже если тип и другой, но значение то одинаковые!

В нём говорится именно о записи значений, а не о типах данных. И именно для такой записи я показал, что на Си результат будет true.

Оспаривать знаковое расширение я абсолютно не собирался и не собираюсь.

PS: А никто из задававших вопрос не хочет высказать своё мнение?

[Хакер]

Берём 16-разрядный Borland C++ 3.1 b компилируем в нём

Не имеем права. Речь идёт о сравнении signed int16 и signed int32. В приведённом коде сравниваются два значения не этих типов.

Как раз наоборот. Вот исходный вопрос:

Это не исходный вопрос. И он содержит ошибку в том плане, что там два значения называны одинаковыми. Значения не являются одинаковыми (типы разные). Запись значений тоже не является одинаковой.

По сути, единственный правильный вариант вопрос такой:

Почему при сравнивании двух значений, запись которых отличается всего лишь на один символ, получается результат «не равно»

Ну и ответ: а с чего ради должно быть «равно»?

[Qwertiy]

Это не исходный вопрос. И он содержит ошибку

Почему исходный вопрос не может содержать ошибку? Это не мешает ему быть вопросом

По сути, единственный правильный вариант вопрос такой:

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

Не имеем права. Речь идёт о сравнении signed int16 и signed int32.

В том то и дело, что это часть ответа на вопрос "почему?". Я же говорю, что Си, в отличие от VB, соответствует ожиданиям автора вопроса

Всё-таки интересно мнение тех, кто спрашивал. А то так можно спорить бесконечно.

[ger_kar]

Всё-таки интересно мнение тех, кто спрашивал.

Мое мнение на сей счет таково. Придумано все было криво изначально и из-за это весь сыр бор, надо было делать, как указывал Майкл. Если число положительное либо отрицательное, то и запись его должна содержать знак, без разнице в какой системе счисления идет запись, тогда было бы все просто и логично.

[Debugger]

Числа с минусом всё равно бы (явно или неявно) приводились к hex-формату без минуса. Потому что ложки минуса не существует.

[Qwertiy]

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

Хм... А кто мешает записать число с минусом?

[Mikle]

А кто мешает записать число с минусом?

-&hA000 - с минусом, положительное...

[ger_kar]

минуса не существует.

Если бы минуса не существовало, то и этот вопрос, с которого началась тема не возник бы. Да если представить запись в двоичном виде, то для &H8000& и &H8000 набор нулей и единиц будет одинаковым, но у процессора есть инструкции сравнения, которые учитывают именно знак числа и из за этого весь сыр бор.

[Хакер]

Да если представить запись в двоичном виде, то для &H8000& и &H8000 набор нулей и единиц будет одинаковым,

А вот фиг.
00000000000000001000000000000000 и 1000000000000000
Набор единиц и нулей не одинаковый.

[ger_kar]

Ну увеличилась разрядность и всего. Но как ни крути сравнить можно либо в 32 разрядном режиме либо 16 разрядном (применительно к данной задаче). Можно например сравнить регистры ACX и BCX, или AX и BX, но не ACX и BX. Поэтому либо к правому значению добавятся незначащие нули слева, либо у левого значения они усекутся, Поэтому сравнивать придется либо
00000000000000001000000000000000 и 00000000000000001000000000000000 либо
1000000000000000 и 1000000000000000
Так что разницы в нулях и единицах для операции сравнения не будет.

[Mikle]

Ты прикалываешься, или действительно считаешь, что unsigned и int — это два разных типа, а не тип и просто-модификатор, который можно приписать к любому целочисленному типу?

Вообще-то, типы, всё-таки, разные. Иначе, если считать HEX запись просто БИТОВОЙ записью числа (ведь речь об этом?), должно быть валидным, например, такое написание:

Код: Выделить всё

Dim a As Single
a = &H3FC00000!

Ведь нас не волнует реальная численная величина, нас волнует правильная битовая запись?
Тогда, действительно, минус для отрицательных не нужен, десятичному разделителю - не место в записи, мы просто указываем порядок битов в константе и, с помощью модификатора "!", указываем тип так же, как указываем тип Long модификатором "&".
После такого будет a = 1.5.

[Хакер]

Ну увеличилась разрядность и всего.

Ты тот факт, что младшие X бит одного Y-битного значения идентичны битам второго X-битного значения, воспринимаешь как «очень многое значит». А надо треснуть себя по голове, и воспринимать этот факт как ничего не значащий. Не совпала разрядность — всё, караул, на биты даже не смотрим. И не нужно говорить, что какая-то инструкция процессора может что-то там сравнить. Нет никаких инструкций процессора на том высоком уровне, о котором сейчас идёт речь. Есть два выражения, для каждого выражения ведётся учёт типа, типы разные, сравнение без конвертации невозможно. Конвертация возможна двумя путями: ZX-конвертация и SX-конвертация. В VB применяется последняя, потому что типы — знаковые.

Можно например сравнить регистры ACX и BCX, или AX и BX, но не ACX и BX.

Не нужно писать о регистрах, даже если не можешь правильно написать названия регистров.

Поэтому либо к правому значению добавятся незначащие нули слева, либо у левого значения они усекутся, Поэтому сравнивать придется либо

Если мы говорим о хоть сколько-нибудь развитом языке (какими являются VB, C, C++ и прочие), то это просто гадкое заявление.
В сколько-нибудь развитом языке не «добавятся незначащие нули слева», а будет произведено Zero-Extension или Sign-Extension, в зависимости от типа выражения. В случае VB — делается sign-extension.
В сколько-нибудь развитом языке не «усекаются биты». Каждый язык с большой опаской относится к такому. И делается не просто отсекание лишних битов, а несколько более умная конвертация. И проверка на то, влезет ли одно число в мало-разрядную переменную. А Си в таких случаях выкидывает вариниг, выражая опасения в том, что потеряется что-нибудь важное. Всё сложнее, чем ты представляешь. Всё не так топорно, как ты представляешь.

Ну и конечно, в сколько-нибудь развитой архитектуре будут инструкции movzx, movsx для Z- и S- дополнения.

Поэтому сравнивать придется либо
00000000000000001000000000000000 и 00000000000000001000000000000000 либо
1000000000000000 и 1000000000000000
Так что разницы в нулях и единицах для операции сравнения не будет.

Проблема в том, что ты вступаешь в спор, совершенно не «рубя фишку». То есть с твоим уровнем знаний надо молчать и слушать.

Вообще-то, типы, всё-таки, разные.

О чём и речь.

Тогда, действительно, минус для отрицательных не нужен, десятичному разделителю - не место в записи, мы просто указываем порядок битов в константе и, с помощью модификатора "!", указываем тип так же, как указываем тип Long модификатором "&".

Слушай, но если тебе не нравится писать
Const gm = &hFEACEA72 подразумевая отрицательное число —22222222, а вовсе не положительное 4272745074, и ты требуешь, что раз число отрицательное, то и в шестнадцатеричной записи должен быть минус, то кто мешает тебе писать так:
Const gm = -&h153158E ' с минусом

То есть возможность записывать отрицательные числа с помощью hex-нотации используя минус тебе дали. Ты требуешь, чтобы всех остальных лишили возможность записывать отрицательные числа с помощью hex-нотации без использования минуса перед hex-записью. Так?

P.S.
Единственное послабление в VB, которое сделали hex-контстантам, так это то, что унарный минус может их переполнять безнаказанно, а десятичные — нет. То есть Const u as long = -&h80000000 написать можем, а Const u as long = -(-2147483648) — нет.

[ger_kar]

Не нужно писать о регистрах, даже если не можешь правильно написать названия регистров.

Самое странное, что я знаю, как правильно писать названия регистров, но почему я так лоханулся и написал такую чушь, сам сейчас сижу и не понимаю. Какие нафиг ACX и BCX, когда EAX и EBX. Видимо был полусонный Ну что же теперь, лоханулся и поделом!

Проблема в том, что ты вступаешь в спор, совершенно не «рубя фишку». То есть с твоим уровнем знаний надо молчать и слушать.

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

[Mikle]

Единственное послабление в VB, которое сделали hex-контстантам, так это то, что унарный минус может их переполнять безнаказанно, а десятичные — нет.

Ооо. Всё ещё хуже, чем я думал, действительно, константа -&H80000000 валидна, и она РАВНА &H80000000. Но при этом -&H8000 даёт ПЕРЕПОЛНЕНИЕ. Это вообще логически не объяснишь.
Хуже того, даже так:

Код: Выделить всё

?-(-&h80000000)

мы получаем ответ:

Код: Выделить всё

-2147483648

Хотя так:

Код: Выделить всё

?-(-2147483648)

имеем ответ:

Код: Выделить всё

2147483648

[Хакер]

В первом случае было переполнение без генерации ошибки, во втором поменялся тип.

[Mikle]

В первом случае было переполнение без генерации ошибки, во втором поменялся тип.

Само по себе "переполнение без генерации ошибки" - уже настораживает, но почему тогда "поменялся тип" тут работает:
?-(-2147483648)
?-(-32768)
Хотя тут смена более неоднозначна, насколько понимаю - в первой строке выходит Double.