С++: как привести 2 байта в массиве к беззнаковому шорту

Ну, вы расширяете char до короткого значения. Что вы хотите, так это интерпретировать два байта как короткие. static_cast нельзя использовать с unsigned char* на unsigned short*. Вы должны привести к void*, затем к unsigned short*:

unsigned short *p = static_cast<unsigned short*>(static_cast<void*>(&packetBuffer[1]));

Теперь вы можете разыменовать p и получить короткое значение. Но проблема с этим подходом заключается в том, что вы приводите тип unsigned char* к void*, а затем к другому типу. Стандарт не гарантирует, что адрес останется прежним (и, кроме того, разыменование этого указателя будет поведением undefined). Лучшим подходом является использование битового сдвига, который всегда будет работать:

unsigned short p = (packetBuffer[1] << 8) | packetBuffer[2];

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

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

Битовый сдвиг выше имеет ошибку:

unsigned short p = (packetBuffer[1] << 8) | packetBuffer[2];

если packetBuffer находится в байтах (шириной 8 бит), то приведенный выше сдвиг может и превратит packetBuffer в ноль, оставив вам только packetBuffer[2];

Несмотря на это, это по-прежнему предпочтительнее указателей. Чтобы избежать вышеупомянутой проблемы, я трачу несколько строк кода (кроме совершенно буквальной нулевой оптимизации), это приводит к тому же машинному коду:

unsigned short p;
p = packetBuffer[1]; p <<= 8; p |= packetBuffer[2];

Или, чтобы сэкономить несколько тактов и не сдвигать биты с конца:

unsigned short p;
p = (((unsigned short)packetBuffer[1])<<8) | packetBuffer[2];

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

Скажем, вы были ленивы и хотели выполнить 16-битную математику в 8-битном массиве. (маленький порядок байтов)

unsigned short *s;
unsigned char b[10];

s=(unsigned short *)&b[0];

if(b[0]&7)
{
   *s = *s+8;
   *s &= ~7;
}

do_something_With(b);

*s=*s+8;

do_something_With(b);

*s=*s+8;

do_something_With(b);

Нет никакой гарантии, что совершенно свободный от ошибок компилятор создаст код, который вы ожидаете. Массив байтов b, отправленный в функцию do_something_with(), никогда не может быть изменен операциями *s. Ничто в приведенном выше коде не говорит, что так и должно быть. Если вы не оптимизируете свой код, вы можете никогда не столкнуться с этой проблемой (пока кто-нибудь не оптимизирует или не изменит компиляторы или версии компиляторов). Если вы используете отладчик, вы можете никогда не увидеть эту проблему (пока не станет слишком поздно).

Компилятор не видит связи между s и b, это два совершенно разных элемента. Оптимизатор может решить не записывать *s обратно в память, потому что он видит, что *s имеет ряд операций, поэтому он может сохранить это значение в регистре и сохранить его в памяти только в конце (если вообще когда-либо).

Есть три основных способа исправить указанную выше проблему с указателем:

1. Объявить s изменчивым.
2. Используйте союз.
3. Используйте функцию или функции при изменении типов.

Вы не должны приводить беззнаковый указатель char к беззнаковому короткому указателю (в этом отношении от указателя меньшего типа данных к большему типу данных). Это связано с тем, что предполагается, что адрес будет выровнен правильно. Лучшим подходом является сдвиг байтов в реальный беззнаковый короткий объект или memcpy в беззнаковый короткий массив.

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

Возможно, это очень позднее решение, но я просто хочу поделиться с вами. Если вы хотите преобразовать примитивы или другие типы, вы можете использовать объединение. Смотри ниже:

union CharToStruct {
    char charArray[2];
    unsigned short value;
};


short toShort(char* value){
    CharToStruct cs;
    cs.charArray[0] = value[1]; // most significant bit of short is not first bit of char array
    cs.charArray[1] = value[0];
    return cs.value;
}

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

char array[2]; 
array[0] = 0x00;
array[1] = 0x03;
short i = toShort(array);
cout << i << endl; // or printf("%h", i);

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

unsigned short *myShort = static_cast<unsigned short*>(&packetBuffer[1]);

Разве никто не видел, что ввод был строкой!

/* If it is a string as explicitly stated in the question.
 */
int byte1 = packetBuffer[1] - '0'; // convert 1st byte from char to number.
int byte2 = packetBuffer[2] - '0';

unsigned short result = (byte1 * 256) + byte2;

/* Alternatively if is an array of bytes.
 */
int byte1 = packetBuffer[1];
int byte2 = packetBuffer[2];

unsigned short result = (byte1 * 256) + byte2;

Это также позволяет избежать проблем с выравниванием, которые могут возникнуть в большинстве других решений на определенных платформах. Примечание. Короткое замыкание составляет не менее двух байтов. Большинство систем выдаст вам ошибку памяти, если вы попытаетесь разыменовать короткий указатель, который не выровнен по 2 байтам (или какой-либо размер sizeof(short) в вашей системе)!

char packetBuffer[] = {1, 2, 3};
unsigned short myShort = * reinterpret_cast<unsigned short*>(&packetBuffer[1]);

Я (пришлось) делать это все время. big endian - очевидная проблема. Что действительно принесет вам неправильные данные, когда машина не любит несогласованные чтения! (и написать).

вы можете написать тестовое приведение и утверждение, чтобы увидеть, правильно ли оно читается. Таким образом, при запуске на машине с обратным порядком байтов или, что более важно, на машине, которая не любит неправильное чтение, вместо странной трудно отслеживаемой «ошибки» произойдет ошибка утверждения;)

В окнах вы можете использовать:

unsigned short i = MAKEWORD(lowbyte,hibyte);

Я понимаю, что это старая тема, и я не могу сказать, что испробовал все предложения, сделанные здесь. Я просто привыкаю к ​​mfc, и я искал способ преобразовать uint в два байта и обратно на другом конце сокета.

В сети можно найти множество примеров сдвига битов, но ни один из них не работает. Многие примеры кажутся слишком сложными; Я имею в виду, что мы просто говорим о захвате 2 байтов из uint, отправке их по проводу и подключении их обратно к uint на другом конце, верно?

Это решение, которое я наконец придумал:

class ByteConverter
{
public:
 static void uIntToBytes(unsigned int theUint, char* bytes)
  {
   unsigned int tInt = theUint;

   void *uintConverter = &tInt;
   char *theBytes = (char*)uintConverter;

   bytes[0] = theBytes[0];
   bytes[1] = theBytes[1];
  }
 static unsigned int bytesToUint(char *bytes)
  {
   unsigned theUint = 0;

   void *uintConverter = &theUint;
   char *thebytes = (char*)uintConverter;

   thebytes[0] = bytes[0];
   thebytes[1] = bytes[1];

   return theUint;
  }
};

Используется следующим образом:

unsigned int theUint;
char bytes[2];
CString msg;

ByteConverter::uIntToBytes(65000,bytes);
theUint = ByteConverter::bytesToUint(bytes);

msg.Format(_T("theUint = %d"), theUint);
AfxMessageBox(msg, MB_ICONINFORMATION | MB_OK);

Надеюсь, это поможет кому-то.