Возможно, глупый вопрос о "пользовательских" целых числах в С#

Добрый день,

Это может показаться глупым вопросом, но было бы очень полезно, если бы это было возможно... Есть ли способ получить пользовательские битовые глубинные целые числа (например, 20-битное целое число) в С#?

Большое спасибо.

ОТВЕТЫ

Ответ 1

Хороший вопрос. Как и большинство вещей, ответ будет зависеть от того, что вам нужно сделать с ним.

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

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

Если вы заданы для целочисленного представления с переменной битовой глубиной, рассмотрите возможность обертывания внутреннего представления. Одной из возможностей может быть использование IEnumerable<byte> и расширение байта байтом по мере увеличения его величины. Записывайте операторы, работающие с динамическим диапазоном. Это может быть необязательно самая оптимальная форма представления или наиболее результативная, но это, вероятно, будет самым простым.

Другим возможным решением может быть что-то подобное, но с "улоном". Это не так эффективно, но мы используем 64-битные операции.

Просто spitballing:)

Надеюсь, это поможет!

Ответ 2

Создайте структуру, которая принимает 32-битное целое число и бит маскирует его с помощью  0000 0000 0000 1111 1111 1111 1111 1111 или (0x08FF)
прежде чем хранить его во внутреннем частном поле.

   public struct TwentyBitInt
   {
      private const int mask = 0x08FF;
      private int val;
      private bool isDef;


      private TwentyBitInt(int value)
      {
         val = value & mask;
         isDef = true;
      }
      public static TwentyBitInt Make(int value) 
      { return new TwentyBitInt(value); }

      public int Value { get { return val; } }
      public bool HasValue { get { return isDef; } }

      public static TwentyBitInt Null = new TwentyBitInt();

      public static explicit operator int (TwentyBitInt twentyBit)
      { 
          if (!HasValue) throw new ArgumentNullValueException(); 
          return twentyBit.val;
      }
      public static implicit operator TwentyBitInt (int integerValue)
      { return Make(integerValue); }

      // etc.
    }

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

Ответ 3

Я думаю, вы можете, но это будет нелегко. Вы можете использовать что-то вроде BitArray для создания произвольной длины строки бит. Затем вам нужно написать весь код самостоятельно, чтобы рассматривать его как целое. Это тяжелая часть.

Ответ 4

Хотя вы не можете создать структуру, которая будет соответствовать точно "20 бит" в памяти, вы можете создать свою собственную структуру, которая будет "вести себя как" 20-битный тип данных (путем хранения частного "обычного" типа данных, и использование побитовых операторов в вашем общедоступном сетевом устройстве для хранения только требуемых битов).

struct TwoBits
{
    int m_data;

    public int Data
    {
        set
        {
            m_data = 0x03 & value;
        }
        get
        {
            return m_data;
        }
    }
}