Извлечь верхнее и нижнее слово 32-битного целого числа без знака

uint16_t lower_word = (uint16_t) nbr;
uint16_t upper_word = (uint16_t) (nbr  >> 16);

маски бесполезны

cast необходимы, иначе компилятор может выдать предупреждение

{отредактировать, чтобы учесть замечание Лундина/Эрика Постпишила}

например gcc -Wconversion выдает предупреждение без приведения

Система типа C одновременно тонкая и опасная. Явное преобразование может быть необходимым, а может и не быть. В частности, в случае (uint16_t) nbr & 0x0000FFFF приведение не является правильным, предполагая 32-битный процессор.

Вы произносите перед операцией. Это означает, что операнд nbr будет явно преобразован путем приведения, а затем немедленно неявно преобразован до int путем неявного целочисленного преобразования. Результат будет иметь тип int, который является подписанным. Безвреден в этом случае, но может вызвать проблемы в других случаях. Используя неправильный состав, вы сделали signed int из uint32_t, что не было целью.

В целом вам необходимо знать правила продвижения неявного типа.

Хотя существует неявное преобразование lvalue при присвоении обратно uint16_t, что в большинстве случаев спасает положение.

Также обратите внимание, что 0x0000FFFF — опасный стиль. Шестнадцатеричные литералы относятся к типу, в котором значение будет соответствовать, независимо от того, сколько нулей вы поставили перед значением. В данном случае это int, который подписан. В 16-битной системе 0x0000FFFF даст int, а 0x00008000 даст unsigned int. (Проверьте, например, эту странную ошибку: Почему 0 ‹ -0x80000000?)

Лучшей практикой, надежным, переносимым, совместимым с MISRA-C кодом является код, который вообще не содержит никаких неявных преобразований:

uint32_t nbr = ...;
uint16_t lower_word = (uint16_t) (nbr & 0xFFFFUL);
uint16_t upper_word = (uint16_t) ((nbr >> 16) & 0xFFFFUL);

Это предполагает, что nbr известно как uint32_t, в противном случае рекомендуется привести этот операнд к uint32_t перед приведением.

В данном конкретном случае маски на самом деле не нужны, но в общем случае, например, при маскировании 4 байтов из uint32_t.

Нет, вам не нужен typecast, и я бы не рекомендовал его использовать. Это связано с тем, что он имеет более высокий приоритет, чем оператор &, поэтому nbr сначала преобразуется в uint16_t, а затем маскируется. По этой же причине вторая строка не будет работать без дополнительных скобок.

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

Если вам нужно повторить эту операцию несколько раз в коде, есть другой способ сделать это с помощью union :

typedef union _uplow                                                                                     
{                                                                                                        
  struct _reg {                                                                                          
    uint32_t low : 16;                                                                                   
    uint32_t up  : 16;                                                                                   
  } reg;                                                                                                 
  uint32_t word;                                                                                         
} uplow;

Объявите свою переменную следующим образом:

uplow my_var;
my_var.word = nbr;

Используйте это так:

printf ("Word : 0x%x\n Low : 0x%x\n Up  : 0x%x\n", my_var.word, my_var.reg.low, my_var.reg.up);

Вывод :

Word : 0xaaaabbbb
 Low : 0xbbbb
 Up  : 0xaaaa