1. C# / Говнокод #16231

    +133

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    public class OctetString 
    {
            private byte[] m_bDataArray = null;
    
            public OctetString(byte[] data_i)
            {
                //copy input data
                m_bDataArray = new byte[data_i.Length];
                data_i.CopyTo(m_bDataArray, 0);
           }
    	
    	//...
    	//checks if a bit on a specfied position is set
    	public bool CheckIfBitOnPositionIsSet(int iPosition)
    	{
    		if (m_bDataArray.Length * 8 < iPosition)
    		{
    			return false;
    		}
    
    		int iByte = iPosition / 8;
    		
    		int iBit = iPosition % 8;
    
    		byte bData = m_bDataArray[iByte];
    
    		if((bData & (0x1 << iBit)) != 0)
    		{
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}
    }
    
    
    byte[] data = { 0xFF, 0x3F };
    OctetString octetString = new OctetString(data);
    
    Assert.AreEqual(false, octetString.CheckIfBitOnPositionIsSet(8));

    Пащимуууу!!!
    Как можно упароцца так?
    m)

    Запостил: blackhearted, 25 Июня 2014

    Комментарии (55) RSS

    • http://ideone.com/4830ZQ
      Ответить
    • Ну во-первых в говноконструкторе можно сразу присвоить массив, а не страдать хуйней

      Ну а дальше я ничего не понял, полный бред.
      Какие-то ненужные манипуляции с длиной массива и 8-кой, побитовое сравнение, упоротый тест.
      Ответить
      • Суть теста - есть строка байтов( октетов), нужно узнать равен ли бит на некоторой позиции 1 или 0.
        Всё.
        У аффтара нумерация байт слева-направо, а нумерация бит в байте справа-налево.
        Ответить
        • > У аффтара нумерация байт слева-направо, а нумерация бит в байте справа-налево.
          Поддержу Кегги. В чем проблема то? Little-endian число первый раз увидел?
          Ответить
          • Каким хером -endian к порядку битов в байте?
            Ответить
            • К порядку байтов в массиве он. А биты с младшего пронумерованы, что с ними не так.
              Ответить
              • То с какой стороны на чип памяти посмотреть...
                А то, перевернёшь - и биты уже вне в том порядке.
                Ответить
                • Ну вот это уже правильная мысль: все 4 варианта имеют право на жизнь :)

                  Кстати, а эта штука участвует в каком-то протоколе с другой прогой, или же ее юзают как банальный BitArray и никогда никуда не передают?
                  Ответить
                  • Она участвует, конечно, в общении по SNMP.
                    Ответить
                    • И эта нумерация битов/байтов соответствует протоколу?

                      P.S. А почему автор пишет свой велосипед, а не поюзал какую-нибудь готовую либу? Разве под шарп нету либ для SNMP клиентов/серверов?
                      Ответить
      • >>Ну во-первых в говноконструкторе можно сразу присвоить массив, а не страдать хуйней
        ага
        и при создании 2 обьектов с одного массива получать побочные явление
        Ответить
    • iPhone, iPad, iPod, iBit, iByte, iPosition
      Ответить
    • А что в коде то не так?
      Полное копирование не говно - из контекста не видно. Если ни копировать передается ссылка, может возникнуть побочный эффект.
      код внутри нормальный. Нет контекста опять же.
      Ну и явное говно одно - не octet а octal
      Ответить
      • Пля, шо серьёзно?
        Т.е. бит №14 равен 0, а бит №8 равен 1?
        Дайте мне пепла.
        Ответить
        • Что бы поливать говном архитектуру мало данных. В этот куске говна, имхо, нет.
          Ответить
          • Да пох на архитектуру.
            Скажи про бит №14 и бит №8!!!
            Ответить
            • 14ый бит во втором байте, а 8ой - в первом. Ты это хотел услышать?
              Ответить
              •  
                Ответить
                • ну так {0xff,0x3f} это 11111111 и 00111111. теперь разворачиваем порядок и получаем строку 1111 1111 1111 1100. хз зачем, видимо нннадо

                  тут мы идем по первому байту от младшего бита к старшему. затем по второму также от младшего к старшему
                  Ответить
                  • Ну и где логика?
                    Ответить
                    • от первого к последнему - вот и вся логика. Чувак, математике пох как ты записываешь, просто мы привыкли от старших к младшим.

                      так тебя устроит?
                      public bool GetBit(int byteIndex, int bitIndex)
                              {
                                  if (byteIndex >= _bytes.Length || bitIndex>7) throw new OctalStringAccessException();
                                  return (_bytes[byteIndex] & (1 << bitIndex)) != 0;
                              }
                      
                              public bool GetBit(int position)
                              {
                                  return GetBit(position/8, position%8);
                              }
                      Ответить
          • И почему не юзать System.Collections.BitArray вместо велосипедика?
            Ответить
            • а может на нужно быстро считывать байты? Вот наша задача подразумевает, что нам нужно часто ворочить байты, но иногда нужно обращаться к этой строке как к цельному массиву бит. чем не нравится?
              Ответить
              • Очередной оптимизатор хуев.
                Когда нужно будет быстро - можно оптимизировать.
                В первую очередь нужно правильно работать, в соответствии с описанием протокола, а потмо уже быстро.
                Ответить
                • > в соответствии с описанием протокола
                  Так все-таки, в каком порядке биты и байты должны лежать согласно протоколу?

                  Судя по коду, порядок такой:
                  Нулевой бит - младший бит нулевого байта.
                  Седьмой бит - старший бит нулевого байта.
                  Восьмой бит - младший бит первого байта.
                  Пятнадцатый бит - старший бит первого байта.

                  Подобный порядок используется очень часто. Но, согласно RFC, должен быть другой?
                  Ответить
                  • >Request for Comments
                    Что, кто-то спрашивал чье-то мнение по этому протоколу?
                    Ответить
                    • Дык всегда спрашивают, пока протокол устаканивается... Видимо, поэтому эти доки и называются RFC.
                      Ответить
                      • Но здесь то мы не знаем что за протокол, может его никого не спрашивали и сразу запилили.
                        Ответить
                  • По протоколу - BitMap.
                    Порядок - прямой, без выебонов [0, 1, ...,7],[8, 9, ..., 15][16, 17, ... 23], ... .
                    Новость для парниши оказалась неожиданной :)
                    Ответить
      • Octet - норм.
        SNMP называет именно так.
        Ответить
        • Octet - это 8 музыкантов или первые 2 катрена сонета. Все, я ушел в шахту, а ты приготовь подробное описание поставленной задачи и мы побеседуем. Лучше - диаграмму классов
          Ответить
      • > Ну и явное говно одно - не octet а octal
        Октет - это восьмибитный байт. Почти во всех RFC так пишут, чтобы всякие педанты не доябывались в духе "а вдруг в моём байте 9 бит?"
        Ответить
    • Пащимуууу!!!
      Как можно упароцца так?
      m)


      блеванул
      Ответить

    Добавить комментарий