Administrace komentářů

Dá se to nějak provést bez tvorby ještě jednoho pole uint16_t o stejné velikosti?

Ano. Například nějak tahle (convert_in_place(...)):

#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

static const size_t SIZE = 100000;
typedef uint16_t narrow_array_t[SIZE];
typedef uint32_t wide_array_t[SIZE];
typedef uint16_t (*narrow_array_ptr)[SIZE];
typedef uint32_t (*wide_array_ptr)[SIZE];

////////////////////////////////////////////////////////////////////////////////
static narrow_array_ptr convert_in_place(const wide_array_ptr wide_array) {
  const uint32_t *source = *wide_array;
  uint16_t *dest = (uint16_t*)source;
  const uint16_t *const end = dest + SIZE;
  while (dest < end) *dest++ = *source++;
  return realloc(wide_array, sizeof(narrow_array_t));  // free extra memory
  // return (narrow_array_ptr)wide_array;              // keep extra memory
}
////////////////////////////////////////////////////////////////////////////////

static int dump_array_to_file(const char *const file_name,
                              const narrow_array_ptr narrow_array) {
  const int output = open(file_name,
                          O_WRONLY | O_CREAT | O_TRUNC,
                          S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
  if (output == -1) {
    fputs(strerror(errno), stderr);
    return EXIT_FAILURE;
  }
  int result = EXIT_SUCCESS;
  size_t to_write = sizeof(narrow_array_t);
  uint8_t *buffer = (uint8_t*)narrow_array;
  while (to_write) {
    const ssize_t written = write(output, buffer, to_write);
    if (written == -1) {
      result = EXIT_FAILURE;
      fputs(strerror(errno), stderr);
      break;
    }
    buffer += written;
    to_write -= written;
  }
  if (close(output) == -1) {
    fputs(strerror(errno), stderr);
    return EXIT_FAILURE;
  }
  return result;
}

int main() {
  // Allocate and populate an array of 32-bit integers.
  uint32_t (*const wide_array)[SIZE] = malloc(sizeof(wide_array_t));
  if (!wide_array) {
    fputs(strerror(errno), stderr);
    return EXIT_FAILURE;
  }
  for (size_t i = 0; i < SIZE; ++i) (*wide_array)[i] = i % 16384;

  // Compact 32-bit integers into 16-bit integers in-place.
  uint16_t (*const narrow_array)[SIZE] = convert_in_place(wide_array);
  
  // Write compacted array to standard output, just for fun.
  const uint16_t *const end = *narrow_array + SIZE;
  for (uint16_t *number = *narrow_array; number < end; ++number)
    printf("%d, ", *number);  // unchecked!
  putchar('\n');              // unchecked!

  // Write the compacted array into a binary file.
  int result = dump_array_to_file("/tmp/output", narrow_array);
  
  free(narrow_array);
  return result;
}

Pokud se nepletu, tento^^^ kód nezávisí na endianness, protože nedělá žádné podivné bitové operace. Tedy na BE vyrobí binární soubor v BE, na LE vyrobí binární soubor v LE. (A pokud se pletu, hned se mi bude někdo posmívat, takže dobře mi tak.)

Nebo přesvědčit fwrite, aby ukládal jen posledních 16bitů z každého prvku a to ostatní ignoroval (tedy ani nevyplňoval nulama).

Ano, tohle by taky šlo, ale musel by se ten fwrite() (nebo write()) volat SIZE-krát, vždycky na ty 2 byty, což by bylo celkem ošklivé a navíc by to bylo závislé na endianness, tj. muselo by se podle LE/BE správně určit, které 2 byty vypsat.