Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате
Форум программистов > Общие вопросы по .NET и C# > Работа с битами в long числах


Автор: Voyager 12.3.2008, 18:22
Необходимо сделать методы, корректно устанавливающие, получающие биты в long числах.
Пока сделал вариант:

Код

public static long SetBit(long Src, byte Bit, bool Set)
        {
            if (Set)
                return Src ^ (1 << Bit);
                //return Src | (1 << Bit);
            else
                return Src & ~(1 << Bit);
        }

        public static bool GetBit(long Src, byte Bit)
        {
            return ((Src >> Bit) & 1) != 0;
        }

Но с long числами при больших значениях битов (<64) наблюдаются глюки, т.к. число становится отрицательным (знаковый 31-й бит все портит).

Автор: Voyager 13.3.2008, 02:25
Придумал такой вариант, может кому пригодится.
Первый вариант:
Код

        static long SetBitA(long Src, byte Bit, bool Value)
        {
            int lo = (int)Src;
            int mid = (int)(Src >> 0x20);
            byte[] buffer = new byte[8];
            buffer[0] = (byte)lo;
            buffer[1] = (byte)(lo >> 8);
            buffer[2] = (byte)(lo >> 0x10);
            buffer[3] = (byte)(lo >> 0x18);
            buffer[4] = (byte)mid;
            buffer[5] = (byte)(mid >> 8);
            buffer[6] = (byte)(mid >> 0x10);
            buffer[7] = (byte)(mid >> 0x18);
            byte num = (byte)(Bit / 8);
            byte bit = (byte)(Bit % 8);
            if (Value)
                buffer[num] = (byte)(buffer[num] | (byte)(1 << bit));
            else
                buffer[num] = (byte)(buffer[num] & ~(byte)(1 << bit));
            return BitConverter.ToInt64(buffer, 0);
        }

        static bool GetBitA(long Src, byte Bit)
        {
            int lo = (int)Src;
            int mid = (int)(Src >> 0x20);
            byte[] buffer = new byte[8];
            buffer[0] = (byte)lo;
            buffer[1] = (byte)(lo >> 8);
            buffer[2] = (byte)(lo >> 0x10);
            buffer[3] = (byte)(lo >> 0x18);
            buffer[4] = (byte)mid;
            buffer[5] = (byte)(mid >> 8);
            buffer[6] = (byte)(mid >> 0x10);
            buffer[7] = (byte)(mid >> 0x18);
            byte num = (byte)(Bit / 8);
            byte bit = (byte)(Bit % 8);
            return ((buffer[num] & (byte)(1 << bit)) != 0);
        }

Второй:
Код

        public static long SetBit(long Src, byte Bit, bool Value)
        {
            byte[] buffer = BitConverter.GetBytes(Src);            
            byte num = (byte)(Bit / 8);
            byte bit = (byte)(Bit % 8);
            if (Value)
                buffer[num] = (byte)(buffer[num] | (byte)(1 << bit));
            else
                buffer[num] = (byte)(buffer[num] & ~(byte)(1 << bit));
            return BitConverter.ToInt64(buffer, 0);
        }

        public static bool GetBit(long Src, byte Bit)
        {
            byte[] buffer = BitConverter.GetBytes(Src);            
            byte num = (byte)(Bit / 8);
            byte bit = (byte)(Bit % 8);
            return ((buffer[num] & (byte)(1 << bit)) != 0);
        }

Автор: Ctrl 16.3.2008, 12:22
Извините за пост в закрытую тему, но наличие бага в исходном примере автора привело к неверным выводам:
 - знаковый бит не 31-й, а 63-й
 - на самом деле проблема рещается гораздо проще (см. мой пример)

Теперь о баге:
Код

return Src ^ (1 << Bit);

Баг в том что не учитывается неявный кастинг выражения (1<<Bit) к типу int, 
ну и кроме того значение Bit может быть недопустимым (>63).
CodeFix: (1<<Bit)  заменить на (0x1L <<(Bit & 0x3F))

Вот тестовый пример:
Код

using System;
using NUnit.Framework;

namespace LongBitsTest {
    class LongFlags {
        public static long SetBit(long source, byte index, bool setBit) {
            long mask = 1L << (index & 0x3F);
            return (setBit) ? source ^ mask : source & ~mask;
        }
        public static bool GetBit(long source, byte index) {
            long mask = 1L << (index & 0x3F);
            return (source & mask) != 0;
        }
    }
    class Program {
        static void Main(string[] args) {
            TestIt();
        }
        protected static void TestIt() {
            Assert.AreEqual(0x0000000020000000L, LongFlags.SetBit(0, 29, true));
            Assert.AreEqual(0x0000000080000000L, LongFlags.SetBit(0, 31, true));
            Assert.AreEqual(0x0000000200000000L, LongFlags.SetBit(0, 33, true));

            Assert.AreEqual(0, LongFlags.SetBit(0x0000000020000000L, 29, false));
            Assert.AreEqual(0, LongFlags.SetBit(0x0000000080000000L, 31, false));
            Assert.AreEqual(0, LongFlags.SetBit(0x0000000200000000L, 33, false));

            Assert.AreEqual(long.MinValue, LongFlags.SetBit(0, 63, true));
            Assert.AreEqual(0, LongFlags.SetBit(long.MinValue, 63, false));

            long testLong = 0x0000000080000001L;
            Assert.IsTrue(LongFlags.GetBit(testLong, 0));
            Assert.IsFalse(LongFlags.GetBit(testLong, 1));
            Assert.IsTrue(LongFlags.GetBit(testLong, 31));
            Assert.IsFalse(LongFlags.GetBit(testLong, 32));
        }
    }
}

Powered by Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)