Что произойдет, если аргументы, переданные в sscanf, будут преобразованы

В данном случае с точки зрения указателя ничего, так как на всех современных машинах указатели одинаковы для всех типов.

Но поскольку вы используете неправильные форматы, scanf будет записывать за пределы памяти, выделенной для переменных, и это неопределенное поведение.

Bonus question: what is the cleanest correct way to do this? I know that now we have the %hhu format specifier (apparently introduced by C++11), but what about a legacy C89 compiler?

Заголовок <stdint.h> и его типы были введены в C99, поэтому компилятор C89 не поддерживает их, кроме как в качестве расширения.

Правильный способ использования семейств функций *scanf() и *printf() с различными типами фиксированной или минимальной ширины — использовать макросы из <inttypes.h>. Например:

#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>

int main(void) {
  int8_t foo;
  uint_least16_t bar;

  puts("Enter two numbers");
  if (scanf("%" SCNd8 " %" SCNuLEAST16, &foo, &bar) != 2) {
    fputs("Input failed!\n", stderr);
    return EXIT_FAILURE;
  }
  printf("You entered %" PRId8 " and %" PRIuLEAST16 "\n", foo, bar);
}

Прежде всего, это, конечно, вызывает Undefined Behavior.

Но такого рода ужасы были довольно распространены в старом коде, где язык C использовался как язык ассемблера более высокого уровня. Итак, вот 2 возможных поведения:

• структура имеет 32-битное выравнивание. Все (довольно хорошо) на машине с прямым порядком байтов: члены uint8_t получат младший значащий байт 32-битного значения, а байты заполнения будут обнулены (я предполагаю, что программа не пытается сохранить значение больше 255 в uint8_t)
• структура не имеет 32-битного выравнивания, но архитектура позволяет scanf записывать в неправильно выровненные переменные. Младший значащий байт значения, прочитанного для qux, правильно перейдет в qux, а следующие 3 нулевых байта сотрут xyz и etc. В следующей строке xyz получает свое значение, а etc получает еще один 0 байт. И, наконец, etc получит свое значение. Это могло быть довольно распространенным взломом в начале 80-х на машине типа 8086.

Для переносимого способа я бы использовал временное целое число без знака:

uint32_t u;
sscanf(s1, "%u", &(foo->bar));
sscanf(s2, "%u", &u);
foo->qux = (uint8_t) u;
sscanf(s3, "%u", &u);
foo->xyz = (uint8_t) u;
sscanf(s4, "%u", &(foo->etc));

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

Код OP — UB, так как спецификаторы сканирования не соответствуют аргументам.

cleanest correct way to do this?

Очиститель

#include <inttypes.h>

void horror1(const char* s1, const char* s2, const char* s3, const char* s4, Foo* foo) {
    sscanf(s1, "%" SCNu32, &(foo->bar));
    sscanf(s2, "%" SCNu8, &(foo->qux));
    sscanf(s2, "%" SCNu8, &(foo->xyz));
    sscanf(s1, "%" SCNu32, &(foo->etc));
}

Самый чистый

При желании добавьте дополнительную обработку ошибок.

void horror2(const char* s1, const char* s2, const char* s3, const char* s4, Foo* foo) {
    foo->bar = (uint32_t) strtoul(s1, 0, 10);
    foo->qux = (uint8_t) strtoul(s1, 0, 10);
    foo->xyz = (uint8_t) strtoul(s1, 0, 10);
    foo->etc = (uint32_t) strtoul(s1, 0, 10);
}