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

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

Сдвиг разряда выше имеет ошибку:

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

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

, Несмотря на который это все еще предпочтено указателям. Для предотвращения вышеупомянутой проблемы я трачу впустую несколько строк кода (кроме quite-literal-zero-optimization), это приводит к тому же машинному коду:

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. Использование функция или функции, изменяя типы.

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

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

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

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

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

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

/* 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 (короткий) в Вашей системе)!

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

я (имел к) делаю это все время. обратный порядок байтов является очевидной проблемой. То, что действительно получит Вас, является неправильными данными, когда неприязнь машины неправильно выровняла чтения! (и запишите).

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

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

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);

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