16ричное число определяется его длиной (количество цифр в числе) и массивом значений 16ричных цифр(типа char). Число со знаком хранится в прямом коде. При выполнении арифметических операций использовать дополнительный код. Память под массив выделяется статически, во время компиляции и задается массивом фиксированного размера
Нужно сделать 3 конструктора, пустой, с hex константой и строкой символов.

Подскажите, как перевести число которое я передам в конструктор в двоичное, и самое главное - в прямой код как. Вообще странно, написано что есть массив значений ШЕСТНАДЦАТЕРИЧНЫХ цифр (char массив), но прямой код подразумевает единицы и нули? 
Как вообще учитывается знак в таком случае? Т.е. hex(0xABCFD) - чему это число равно в прямом коде? Вот -5, 10, 15 я знаю чему равно, а тут же беззнаковая константа или как? Мне говорили что можно считать что знак задан в самом числе, т.е. ABCDF перевести в двоичное и первая цифра знак - но я чето совсем не понимаю о чем речь, ведь тогда число теряется...

Вообщем можете привести пример, например создать 2 класса и сложить их (ну там перегрузить + - надо будет ещё). Меня именно эти коды угнетают   

Если старший бит равен 1 то число отрицательное, т.е. если старший разряд больше 7 - число отрицательное.

Думаю, что можно за счет длины шестнадцатиричного значения, можно легко вычислить цифровое значение, простым деление, а потом его в двоичное переконвертить, хотя наверника лекго можно и сразу, но толкьо как???   

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

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

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

Добавлено @ 16:42

шестнадцатиричное в двоичное переводится простой заменой 1 hex цифры 4 bin цифрами:
 

Это сообщение отредактировал(а) zkv - 1.11.2007, 16:45

Все равно не пойму. Если я переведу 16ричное число в двоичное я получу прямой код? 


Прямой код FFF не равен FFF же. Т.е. нужно перевести в двоичное. И я уже получу вместе со знаковым разрядом ?
Странно, почему тогда мы не говорим что числа 864 отрицательное или какое там, судя по первому разряду?  А только для шестнадцатеричных? 

F = 1111, получается 1.111 но это уже другое число, когда мы 1 бит под знак берем число же меняется

А если число без знака задано, как я его в прямой код запишу. Там конструктор с 16ричной константой... 

Щас прочту полностью ссылки, но просто мы когда то это проходили сквозь пальцы, и везде помню указывался знак. Для меня эти коды муть. Особенно что число FFF отрицательное, а 111 положительное. А как сделать положительное число записанное в десятичной системе как 255 - шестнадцатеричным если fff отрицательное.. ерунда ) 

Ripper, ты не понял 

НЕ ВАЖНО в какой системе число, значение его не меняется.
Какая разница как ты запишешь: 12(dec) или С(hex) или 1100(bin). К примеру ты пересчитаешь баранов в двоичной системе счисления, а потом в десятичной, их количество от этого не изменится, верно?   
Просто когда описывают хранение чисел в ячейках памяти, удобнее объяснять в двоичной системе. Шестнадцатиричная удобна тем, что запись числа краткая и число можно не напрягаясь в уме конвертнуть в двоичную систему. С десятичной понятно.
Уяснили, в какой бы системе число не представили суть его не меняется.


это неверное утверждение в общем случае. 
FFF(hex) == 1111 1111 1111(bin), все будет зависеть от разрядной сетки (ее размера)
допустим числа у нас хранятся в доп. коде.
1. допустим у нас число представлено 16 битами,  получается, что для хранения значения числа мы используем 14 бит, а 2 для знака и контроля переполнения. в этом случае FFF означает:
0000 1111 1111 1111 - впереди 2 нуля -> доп. код равен прямому коду - в прямом коде, и равен 2^12 - 1 в десятичной системе.
2. допустим у нас число представлено 12 битами,  получается, что для хранения значения числа мы используем 10 бит, а 2 для знака и контроля переполнения. в этом случае FFF означает:
1111 1111 1111 - впереди 2 единицы - это отрицательное число, можешь самостоятельно перевести его в обратный и прямой коды (алгоритмы имеются), можешь найти его десятичное представление (мне что-то не хочется считать  ), помним, суть числа от перевода не изменится, сколько баранов оно обозначало, столько и будет обозначать дальше.
3. допустим у нас число представлено 13 битами,  получается, что для хранения значения числа мы используем 11 бит, а 2 для знака и контроля переполнения. в этом случае FFF означает:
0 1111 1111 1111 - впереди 0, затем 1, не помню что именно это обозначает, но какую-то бяку вроде переполнения в результате некоторых операций, те это число - инвалид, и вообще не может быть никуда переведено (вернее его сначала нужно привести к нормальному виду, какими-то хитрыми способами)

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

Еще заметь, что если бы мы рассматривали хранения беззнаковых целых, то все биты были бы использованы для хранения значения числа, и число FFF даже в 12 битной сетке означало бы 2^12 - 1.

Надеюсь что-то прояснил.

Все равно туго. Я понимаю что одно число в разных системах означает одно и тоже
Не говоря уже как это все в классе описать.
Допустим у нас класс - десятичное число. Мне нужно создать два объекта, в которых будут хранится десятичные числа. 
Я хочу первому присвоить -5. второму 3. и сложить их
Что такое -5? не бывает же -FFF. Значит и 10 числа должны представлятся и рассматриватся с помощью разядной сетки
Или допустим
1111 1010 0011 1101. Что это за число? 11 отрицательное вроде. А САМО значение это что? Все 16 цифр? Если 14 - то оно же портится. 
Я все равно не понимаю смысла. Когда мы решали примерчики н эти коды у нас было что то вроде
3+5 = ? Мы оба представляли в прямом коде, потом в дополнительном потом складывали и потом обратно в прямой и находили ответ .Вроде так. Но тут знак известен. А что значит конструктор, с 16ой константой, я туда же знак не передам вообще. 
вот нужно выполнить действия -452+23 в десятичной. Но я незнаю какой знак когда передаю конструктору. Как компьютер определяет этот знак на основе первых разрядов, это же не верно? Отбрасывается 1-2 разряда (в разных кодах) и само число имеет другой вид. 

Что значит с 8 до F числа отрицательные? т.е. F1 = 1111 0001 = 11. 110001 = число с отрицательным знаком и модулем 110001 = чему то другому? 

Еслиб задавался знак, было бы как то понятней чтоли... Хотя как это выглядит в си вообще ужс 

все очень просто. в 16-тиричной системе счисления нет понятия "отрицательное число". Просто потому, что это лишь цифро-буквенная трансляция тетрады бит. Но, искуственно было введено (на основании математики, конечно), что число, у которого старший бит включен является отрицательным. Но надо иметь в виду, что -10 - это 0xF6 (для байта), а не 0x8A. Почему? А потому что: 0x0A + 0xF6 = 0x100. Но, так как у нас исходных только два разряда, то отбросив 1 получаем 0x00. Что и требовалось доказать.
Но тут сразу может возникнуть вопрос, а как можно представить -255 в 16-тиричной системе, ведь 255=0xFF уже имеет установленный старший бит. Проблема в том, что с начала жизни мы привыкли к тому, что количество разрядов чисел у нас не ограничено. А в компьютерной технике все по-другому. Поэтому программисты постоянно должны понимать, достаточно ли размера переменной, для хранения необходимого диапазона чисел. Исходя из этого, для хранения -255 нужно выбрать минимум 3 разряда, но обычно их степень двойки...

bsa, Как тогда определить чему равно -10? Я написал 1000 1010 но это не верно... 
и как мне получить прямой код в си? Т.е. перевести из 16 в 2 ?  

-10 == 0 - 10 == 0х00 - 0х0A = 0x100 - 0x0A == 0xF6
или
-10 == -00001010 == 11110110 (инверсия всех битов и прибавление единицы) == 0xF6

понимаешь в чем дело, изначально все в компе хранится в 2-м виде. А уже ПО позволяет тебе видеть в других системах счисления.
Если тебе нужно вывести на экран число в двоичном виде, то нет ничего проще - воспользуйся операторами побитного сдвига вправо (>>) и побитовой "И" (&):
А в 16-тиричную переводится тоже легко. Опять же надо воспользоваться сдвигом, операцией "И" и выборкой из таблицы:Хотя, для перевода в 16-тиричную и обратно можно использовать стандартные средства, например printf/scanf и iostream (манипулятор std::hex).

то что ты написал про -10 это помойму дополнительный код уже (инверсия и прибавление еденицы) а в прямом коде это 10001010 
Но вопрос в том, если я переведу число в двоичный код я получу прямой код? -10 = прямой код равен 10001010. А A5? Тут мы не пишем знак, значит он в самом числе? Тогда прямой код 10100101? 

Ещё раз, но по шагам.



Дополнительный код служит для представления отрицательных чисел. Единичка в старшем разряде лишь свидетельствует (признак) о том, что число отрицательное (но просто добавив её, нельзя получить то же число, но с другим знаком). Например, число 3: 0011. Как ты делаешь. то -3 будет 1011 - это неверно. Легко проверить.

Теперь правильное представление -3: ~0011+1 = 1101:

Я не помню уже, что происходит с той единицей, что вылазит за пределы разрядной сетки. По идее. её контролировать не надо. А вот единичка в старшем разряде как-то используется (но я уже забыл как). Знаю, что есть команды, которые ипользуют признак того, что число отрицательное. Например, число итераций на языке ЭВМ, которую я проходил (упрощённый ассемблер) задавалось отрицательным числом, команда ISZ. кажется. После каждой итерации значение увеличивалось на 1. Проверялся именно старший бит (были так же описаны микрокоманды, составляющие данную команду).

Это сообщение отредактировал(а) powerfox - 2.11.2007, 18:20

Прямой код я верно пишу. 
[-3]Прямой код =  0011. 
[-3]Обратный = 1101
Меня волнует то как это все дело на Си будет. Если я переведу число в двоичную систему я получу прямой код. потом мне его нужно инвертировать и добавить еденицу. Можно пример как это все делается, когда у меня два конструктора, один из них с hex константой другой со строкой. Вообще меня именно волновал вопрос получу ли я прямой код если переведу число ПРОСто в двоичный код. 
Вот -3 перевести на бумаге понимаю как, а A5 допустим? Если я переведу А5 в двоичный код я получу ПРЯМОЙ код?  (не дополнительный) 
мне нужно хранить всё в прямом коде. а дейсвтия выполнять в дополнительным. Покажите просто пример как из строки и/или константы поулчить прямой код, и сложить два числа в дополнительном например..  

Получение прямого кода из двоичного-дополнительного (или любого другого):

И в другую сторону:

Числа подразумеваются 32х битными.

Перевод в/из шестнадцатеричной строки вообще делается элементарно - старший бит прямого представления преобразуется в знак '-', остальные биты формируют число (всегда положительное).

Пример:


В твоем случае вместо целого 32х битного числа надо будет использовать многобайтное число, представленное в виде массива.

O_o
А зачем??? Это ведь просто "портит" число... Ведь простой оператор минус всё сделает сам...
Если уж и реализовывать в виде int, то использовать арифметические операторы.

Преобразовывать ничего не надо, как уже сказали: число, оно и в Африке число. Просто оно может быть записано по-разному (если уж не понятно, как объясняли выше, то пример - римские и арабские числа).
Как я понял, то просто надо получить массив char, который является представлением числа. Можеро реализовать посимвольный ввод, и писать в массив по числу (либо в двоичном, чтоб юзер вводил, либо в 16x). Если же хочется конструировать представление в виде массива из int, то, на мой взгляд, самое простое - использовать cout и записать в буфер число в нужном представлении. А затем уже прочитаь оттуда по цифре.


Это сообщение отредактировал(а) powerfox - 2.11.2007, 19:35

Автору темы нужно было реализовать ПРЯМОЕ представление числа, а в компьютере используется ДОПОЛНИТЕЛЬНОЕ. Очевидно, что арифметику над этим ПРЯМЫМ представлением ему придется писать самому, 'простой оператор минус' расчитан на ДОПОЛНИТЕЛЬНОЕ. Но в его случае ему всеравно придется писать арифметику самому, так как у него будет арифметика с числами произвольной длинны (не 32 бита).
Ну надо человеку! Что поделать, задание такое 
Кстати, в его случае имело бы смысл вообще хранить знак отдельно (не в старшем бите).

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

Хорошо, пользователь ввел строку (массив чаров) равную 8AB.  Что должно быть в классе в массиве том? 
Вот число которое в африке число... и неважно в какой оно системе - ну и чего
По мне так как я понял нужно 8АБ представить в двоичном, и записать в массив чаров - это будет прямой код, потом если первая цифра 1 то его инвертировать и прибавить еденицу. Получить дополнительный код. А потом сложение вычитание реализовать
Тока я пока не особо представляю как я это все сделаю, например 1)Разрядная сетка это sizeof(int)*8? 2)допустим два байта 16 бит а число AB в шестадцатеричной. значит 0000 0000 1010 1011 ? А какую тогда цифру вообще проверять, вот 00000000010101011 это записано будет в массиве, но как определить что есть первая. Или наверно нафиг ненужно нули писать. А если ввести AAAAAA то типа переполнение ?
Нет, все равно тупик)))  

Добавлено через 4 минуты и 51 секунду
1A - 0001 1010 - что здесь старший бит? [0]001 1010 
A1 - 1010 0001 а здесь [1]010 0001. Т.е. это отрицательное число с модулем 1010 0001 ?

Ripper, ты сначала определись, что именно вводит пользователь. Если он может вводить -8AB и 8AB, то тебе нужно в дополнительный код переводить только число с минусом.

Да вроде не сказано в задании как вводить. сказано перегрузить >> <<. Но ведь тут говорят что нет такого понятия как отрицательное число для 8AB. оно отрицательно если первая цифра больше 7. 
Вводить как я понял нужно числа не указывая явно знак.
Тогда что должно быть в массиве в классе, если введены 1А и А1. что здесь будет модулем а что знаком? 

Что значит прямое?

Вспомнилась сказка про белого бычка. Тут уже не раз прозвучало. Что есть 2 варианта работы с числом:
1. Хранить его в виде int. Все операции для такого числа есть. Лишь написать функции для представления его в формате, который требует условие (массив char). Вот и всё. Настраиваем, чтобы cout выводила числа в формате hex, выводим в буфер и читаем по цифре в массив. Задание выполнено.
2. Сами реализуем класс и соответствующие операции (в условии я нашёл только сложение), но нам также нужно преобразование в доп. код. Можно реализовать оператор побитового оператора и сложения с int (для приьавления единицы). Неограниченная длина - делаем вектор char и поле класса, которое хранит разрядность. Ничего такого, чтобы спорить.


Задание можно понять немного по разному, а реализовать - так вообще множество вариантов.

Добавлено через 3 минуты и 14 секунд
Что-то лень читать особо. Но что за навороты пошли с модулем и числом по отдельности? Всю жизнь число было "единым". Просто определённые разряды интерпретироваться могут по-разному. И зачем тут понятие модуля, если числа целые. Знаковый разряд и само число (модуль числа). Ввоидится вместе.

Ripper, ты получаешь всё число, но проверяешь старший разрад (чтобы узнать знак числа).

Аа, понял. От вас просят упрощённо.

http://khpi-iip.mipk.kharkiv.edu/library/d...ra/chapter2.htm

Почему то мне кажется, что от вас хотят получить представление с явным знаком, т.е. или '8AB' (положительное) или '-8AB' (отричательное) и не заниматься никакими интерпретациями никаких старших битов  Так что в массиве должно лежать 8AB (в бинарном виде или в символьном или еще в каком - неважно), а знак должен лежать ВООБЩЕ отдельно, например так:

зачем хранить знак?
Ripper
по разрядности числа лимитированы или нет?
если лимитированы (допустим, 32 разряда)
хранить нужно int
а потом в зависимости от представления, которое нужно получить, преобразовывать этот int

При внимательном изучении первого поста можно сделать выводы:
1) Разрядность лимитированна и много больше, чем 32 бита (int не подойдет)
2) Входные данные представленны в ПРЯМОМ коде (читай - с отдельным знаком), при выполнении операций нужно использовать ДОПОЛНИТЕЛЬНЫЙ код - т.е. имеет смысл данные в конструкторе конвертировать в бинарный дополнительный код и именно в таком виде и хранить (в током случае отдельный знак, как я предлагал ранее, не нужен)

Так. Ещё раз. 16ричное число определяется его длиной (количество цифр в числе, например, до 31) и массивом значений 16ричных цифр (типа char). Число со знаком хранится в прямом коде.

Так что хранить в моем массиве, с одной стороны это массив значений 16ричных чисел. А где хранить прямой код? Тока не говорите что числа везде одни и теже и прямой код один и тотже. Прямой код нужно в двоичном представлении хранить как я понимаю. 


и ещё вопросик

Как эта ф-ия работает? Извините, мне сложно на си переходить с др. языка, поэтому туго осваиваюсь. return "1111" это что, это разве указатель на тип чар? И как её потом использовать, пользователь вводит строку (массив char-ов) в виде 1FF (т.е. hex число) и мне нужно в другой массив записать это дело в 2 коде... 

Тока я так и не понял что туда писать :(

Зачем тебе двоичный? У тебя в ТЗ про двоичное ничего не сказано. Храни только прямой код и знак, который будешь учитывать при арифметических операциях.

И как узнать старший бит? Блин. 
В самом hex числе уже зашит знак. А как тогда производить действия в дополнительном коде? Я незнаю что такое дополнительный код в 16ричном виде. 
пользователь вводит FF+2A
1111 1111 + 00101010. Беремь инвертируем и единицу добавляем 0000 0001 11010101 и складываем. Ну что то в этом роде. Ну разве не так?
Пользователь не должен вводить "+FF" - "-FBA"

Не надо хранить число внутри класса в hex виде - храни в бинарном. В задании сказано только про ввод/вывод числа в hex - это не значит, что и внутри должен быть hex
И старший бит тебе не нужен - арифметика (+/-) делается буз учета старшего бита.

В шестнадцатиричном просили прямой код т.е. FF+2A это сумма двух ПОЛОЖИТЕЛЬНЫХ чисел

Нет, просто складываем 1111 1111 + 00101010 (предполагается, что длинна чисел более 8ми битов, иначе в исходных числах ошибка - FF не представимо в виде 8ми битного числа со знаком)


Пользователь МОЖЕТ вводить "+FF", и ДОЛЖЕН вводить "-2A"

xvr, Завтра спрошу у препода. я уже незнаю чему верить
-2A - для шестнадцатеричных числе  не определно понятие отрицательное число (гдето выше писали) т.к. первый бит указывает на знак
значит ненужно вводить знак явно.

Если мы можем написать -42, то почему бы не написать -2A ?
И первый бит указывает на знак не у шестнадцатиричных чисел, а у чисел в дополнительном коде - это абсолютно независимые понятия. С тем же успехом мы можем считать десятичные числа представленными в дополнительном коде, т.е. например  (для 8ми битных чисел) 200 будет соотвествовать -56. Требовать от внешнего представления класса, что бы hex числа для ввода/вывода были представленны в дополнительном коде (равно как и влюбом другом), это все равно, что требовать, что бы вместо числа -56 вводили 200.

Тебе просто советовали вводить дополнительную переменую для знака. Иначе нужно при любой операции "извлекать" знак из числа.

Добавлено через 1 минуту и 59 секунд

xvr, цель 16-й чисел - облегчить работу с двоиным кодом. Кто работает с ними сразу может скачать, что в старшем бите.

Цель 16х чисел (В ДАННОМ СЛУЧАЕ) облегчить реализацию класса - многобайтовое преобразование hex<->bin делается легче, чем dec<->bin, но что то мне кажется, что об облегчения реализации, которая требовала бы ЯВНОГО кодирования отрицательных чисел в дополнительном виде речь все таки не шла  Все таки, когда программы пишутся для пользователей их (пользователей) никто не заставляет вводить отрицательные числа в дополнительном коде, и писать 4294967295 вместо -1
Ы?

Не вижу принципиальной разницы. В С++ есть средства, которые позволяю быстро преобразовать dec в hex. Это всего несколько дополнительных строк.
И в условии явно сказано, что числа хранятся в прямом коде, а в прямом знак указывается в знаковом разряде. 


Согласен. Но "ЗАДАНИЕ" есть задание. Можно просто реализовать дополнительный конструктор для чисел, записанных в форме -N.

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

И для многобайтовых (>8) чисел тоже есть? И давно?
Не хранятся, а ЗАДАЮТСЯ. Про формат хранения не сказано. Кроме того, знак для прямого представления может хранится где угодно - он не используется для выполнения операций (меняются сами операции, но знак в них не участвует)
Собственно ЗАДАНИЕ этого не требовало 
Да собственно сам автор уже уточнил:

Теперь вопросы касательно самого языка. 
1)Как я всеже понял я должен перевести hex число в двоичное и записать его в массив. 

Вот так коряво я это делаю, используя ф-ию:

Единственный вопрос почему последний элемент numer[x] а не number[x+1] = '\0'? что то я скока не считал получается вроде x+1. И может есть более прямой способ это сделать?
Теперь вопрос, а как перевести из массива чаров типа "101010101" в hex число (которое потом нужно будет вывести на экран). Т.е. мне нужно будет перегруживать куча операторов. Один из первых это "<<". Вот я что-то додуматься не могу, как бы это нормаьно сделать. 
Наверно не хватает знаний самого си. Я надеюсь я верно понимаю что в ф-ии приведенной выше return "1111" означает указатель на массив чаров 1111? на начала массива?  
По аналогии что-то не доходит как сделать. 

Не надо так делать. Это САМЫЙ неудобный вид хранения числа.
Именно. И каждый оператор будет одним большим геморроем   
Потому что в цикле for(int j=0; j<4; j++,x++,tmp++)  х будет инкрементирован после последней записи в выходной массив.
Да. Получится строка с символьным битовым представлением, выполнять какие либо операции с ним крайне неудобно, хотя бы потому, что у него СТАРШИЕ разряды будут в начале массива, при этом их вес будет зависить от длинны числа, для арифметики это полный кирдык :(
Есть. Надо использовать БИНАРНОЕ (а не текстовое) представление. Примерно так:
Арифметику сам напишешь 

Это сообщение отредактировал(а) xvr - 7.11.2007, 23:23

sizeof(long int) 
Я думаю, что этого вполне достаточно в большинстве случаев (32, а уж про 64 так вообще молчу).

Не, мой мозг не в состоянии этого понять.
Попробую сделать хоть что-то, храня hex числа в массиве...  
:(

sizeof(long int) это 4 (максимум 8), хотелось бы больше 
Угу, особенно для целей криптографии, арифметики большой точности (типа вычисления числа пи с точностью 1млн знаков) и пр  
Сдается мне, что там, где достаточно 32 или 64 бита, классы, такие как фигурировал в задании, не применяют - там и так все просто и прозрачно, со встроенными POD типами.

Добавлено через 1 минуту и 27 секунд

Для начала напиши арифметику с таким представлением, если получится, то и hex ввод/вывод получится тоже.

xvr, мне не хватает знаний по си. мы много чего в инсте не проходили и как бы отсюда следует что это использовать нельзя
И я уже так запарился с этим заданием ужас)
1)template<int Length> что это?
2)что такое <<= ? в побитовых операциях ненашел такого
3)что значит прибавить к *this число? Переместить указатель на объект? что получится?
4)в задании сказано использовать массив char-ов а не int-ов
5)+ ко всему я не понял этот код т.к. незнаю вообще встроенных в си ф-ий, конечно могу посмотреть где нибудь описание, но я к другому клоню - что щас мне это совсем тяжко. Препод сказал сначала можно в hex виде хранить т.е. в массиве чаров 16ричные числа, потом сказал по другому.. Вообщем посмотрим, сделать нужно хоть как-то. Когда 16ричные числа в массиве вроде легче

Если вы многого не проходили, то это не значит, что это нельзя использовать. Максимальное ограничение - конкретная реализация язык (компилятор).
И то, что здесь идёт - не Си, а С++.

Мусье учится на первом курсе?



Шаблон, судя по записи. Я с ними плохо знаком, но Length как-то странно здесь смотрится. Обычно указывается просто тип (int в данному случае).



<<= - это оператор. Сдвиг влево и присваивание. Принцип такой же, как и +=, который намного чаще используется.


this - укзатель на объект, для которого вызван метод. А *this - сам объект. Обычное разыменовывание.


Посмотри базовые сведения о типах в С/С++.

Это шаблон, параметризованный константой (не типом). Константа задает длинну представимых чисел (в единицах по 32 бита)
Это значит разыменовать this (получится экземпляр класса, а не указатель), потом к этому экземпляру применить оператор +=
Все тоже самое можно сделать и в char'ах, ничего (кроме некоторых констант, задающих длинну элемента массива) не изменится
Попробуй написать арифметику с ними (+ - и изменение знака), тогда сразу поймешь, что легче 

Эээх...
1)Можно без шаблонов? Ну не хочется щас читать ещё одну главу в шилде про шаблоны. наверно можно без них
2)И что значит прибавить к экземляру класса число? Этот оператор не реализован, а что он  в итоге должен делать? 
3)Я вообще не понимаю что этот код делает. 
*this += strtoul(s,0,16); 
memset(body,0,sizeof(body));
Что это за ф-ии? 
4)<<= всмысле сдвиг влево и присваивание.. например *this<<=4? 
"<<" знаю вроде, например 1010 после сдвига 0100 (влево). а какой смысле будет у *this<<=4? 

Я пробую так все это делать:
Только незнаю насчет 3 конструктора и ввода >> пока ещё. 

Можно и без шаблонов, тогда длинна числа, которое может хранить класс будет фиксированна (как у тебя и сделано)
Какая-нибудь арифметика для этого класса планируется или нет? Этот класс должен описывать число или просто вводить и выводить hex строку? Если это всеже класс, описывающий число, то и вести он себя должен как число. Т.е. уметь складывать себя с другим экземпляром этого же класса. Так же для класса описан конструктор из int - т.е. он будет автоматически создаваться из int при необходимости.



strtoul(s,0,16) - преобразует строку s (которая в свою очередь состоит из одного символа из входной последовательности) в число по основанию 16 (т.е. односимвольный hex в обычное число)

*this += ... прибавляет это число к текущему значению класса.

Эквивалентно my_number = my_number << 4, не забывай - твой класс это ЧИСЛО, и все арифметические операции с ним выполняются как с обычным ЧИСЛОМ (только очень большим)

Эта конструкция полностью эквивалентна
Она просто копирует переданный ей параметр во внутренний буфер. Теперь объясни мне, что ты собираешься с этим буфером дальше делать? Работать с ним как с числом НЕВОЗМОЖНО.