OriginalGriff
Здесь очень много проблем...
while(i<0){
Таким образом, он войдет в цикл только в том случае, если пользователь введет отрицательное число...
Исправьте это, и это никогда не закончится:
while(i>0){
i=a;
Потому что вы сбрасываете переменную цикла каждый раз вокруг цикла...
Исправьте это, и бит внизу достанется вам:
c=i%2;
switch(c){
case '0':
i=i/2;
case '1':
i=(i-1)/2;
}
По двум причинам:
1) c никогда не будет равно символу " 0 " или " 1 " - потому что это остаток, когда он делится на 2, так что это число 0 или 1, и они разные.
Исправить это:
c=i%2;
switch(c){
case 0:
i=i/2;
case 1:
i=(i-1)/2;
}
И это все еще не работает правильно - хотя это немного лучше - потому что это падает через
case 0
к
case 1
.
Исправить это:
c=i%2;
switch(c){
case 0:
i=i/2;
break;
case 1:
i=(i-1)/2;
}
И он почти там - не совсем, но приближается - достаточно близко, чтобы вы могли исправить оставшиеся проблемы.
Вы могли бы решить все это для себя, просто точно следуя тому, что делал код - и вам, вероятно, нужно будет сделать это, чтобы исправить последнюю проблему.
Так что все будет зависеть от тебя.
К счастью, у вас есть инструмент, который поможет вам выяснить, что происходит: отладчик. Как вы его используете, зависит от вашей компиляторной системы, но быстрый поиск в Google имени вашей IDE и "отладчика" должен дать вам необходимую информацию.
Поместите точку останова в первую строку функции и запустите код через отладчик. Затем посмотрите на свой код и на свои данные и определите, что должно произойти вручную. Затем по одному шагу в каждой строке проверяйте, что то, что вы ожидали, произойдет именно так, как и произошло. Когда это не так, тогда у вас есть проблема, и вы можете вернуться назад (или запустить ее снова и посмотреть более внимательно), чтобы выяснить, почему.
Извините, но мы не можем сделать это за вас - пришло время вам освоить новый (и очень, очень полезный) навык: отладку!
Цитата:
Я попробовал это сделать, но я хочу перевернуть число, а также числа, делящиеся на 2, дают проблему.
Да, они будут - потому что вы не знаете, как "покончить с вещами"
И перевернуть число-это именно то, что вы хотите сделать. Это означает поиск наиболее значимой двоичной цифры и печать оттуда, или всегда печать одного и того же количества двоичных битов.
Я не знаю, над какой системой вы работаете, поэтому я не знаю, насколько "велико" целое число: оно может быть 16 бит:
−32,768 through 32,767
Или 32 бита:
−2,147,483,648 through 2,147,483,647
Но если мы примем более низкий диапазон и проигнорируем негативы, то это довольно просто.
То, что вам нужно, - это смещающая маска: сначала она изолирует один бит в самой высокой позиции, затем вы сдвигаете его вправо, чтобы в следующий раз он выглядел на один бит ниже.
Итак, попробуйте вот это:
int x = 32766;
int mask = 0x4000;
int print = 0;
while (mask != 0)
{
if (print || (x & mask))
{
printf("%d", (x & mask) ? 1 : 0);
print = 1;
}
mask >>= 1;
}
printf("\n");
Измените начальную настройку
print
и он будет "фиксировать" количество битов на "все 15".
Как это работает?
Что ж... начальное значение
mask
это один бит: bit14 (нумерация начинается с 0 для наименее значимого здесь): в двоичном формате это:
100000000000000
Единица, за которой следуют четырнадцать нулей.
Установка
print
значение 0 делает его "ложным" в том, что касается C - у него нет встроенной идеи "истинного" или "ложного", поэтому любое ненулевое значение истинно, ноль ложен.
Мы петляем в то время как
mask
все еще есть биты, чтобы проверить.
Внутри петли мы проверяем: если
print
если цифра ненулевая, то мы всегда печатаем цифру, иначе проверяем
x
с
mask
. Этот
&
оператор в C делает a
BINARY AND
: он возвращает значение, в котором только те биты, которые равны 1 в обоих операндах, все остальные равны нулю. С
mask
содержит только один бит, он изолирует значение этого бита в X. (Если вы не понимаете, Википедия может помочь вам с картинками)
Если мы получаем "go" от любого из них, мы печатаем двоичную цифру и всегда устанавливаем
print
к ненулевому значению, чтобы гарантировать, что все последующие цифры печатаются независимо от того, равны ли они нулю или единице.
Затем мы сдвигаем
mask
одно правильное место: 0x4000 становится 0x2000, 0x1000, 0x0800, ... готов к следующей цифре.
Когда мы напечатали бит 0,
mask
будет один, поэтому сдвиг сделает его нулевым, и это остановит цикл.
В этом есть смысл?