Pole v C++ pro předčátečníky a začátečníky

/*
(a) clang++ -Wall -Wextra -Wno-vla{,-extension} -pedantic -march=native -O3 \
            -std=c++17 ./array.c++ -Wfatal-errors -o array
(b) g++ -Wall -Wextra -Wno-vla{,-extension} -pedantic -march=native -O3 \
        -std=c++17 ./array.c++ -Wfatal-errors -o array
*/

#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <vector>

namespace {

// Archaická metoda z C; lépe nepoužívat! Jen ukákza zoufalství.
void a(const size_t array_size) {
  int32_t *const array{
      static_cast<int32_t *>(std::malloc(sizeof(int32_t) * array_size))};
  const int32_t *const array_end{array + array_size};
  size_t counter{array_size};
  for (int32_t *p = array; p < array_end; ++p) *p = counter--;
  for (const int32_t *p = array; p < array_end; ++p)
    std::cout << *p << std::endl;
  std::free(array);
}

// O fous lepší; inicializace je sice v C, ale iterace je v C++.
void b(const size_t array_size) {
  int32_t *const array{
      static_cast<int32_t *>(std::malloc(sizeof(int32_t) * array_size))};
  size_t counter{array_size};
  for (auto &i : *reinterpret_cast<int32_t(*)[array_size]>(array))
    i = counter--;
  for (auto i : *reinterpret_cast<int32_t(*)[array_size]>(array))
    std::cout << i << std::endl;
  std::free(array);
}

// Skoro C++, ale pořád musí se volat delete[], takže nic moc.
void c(const size_t array_size) {
  int32_t *const array{new int32_t[array_size]};
  size_t counter{array_size};
  for (auto &i : *reinterpret_cast<int32_t(*)[array_size]>(array))
    i = counter--;
  for (auto i : *reinterpret_cast<int32_t(*)[array_size]>(array))
    std::cout << i << std::endl;
  delete[] array;
}

// Předchozí trik, jen snáze zapsaný -> kvůli potížím s C++ standardem nic moc.
#ifdef __GNUC__
void d(const size_t array_size) {
#ifdef __llvm__
  int32_t(*array)[array_size];
  *reinterpret_cast<void **>(&array) = new int32_t[array_size];
#else
  int32_t(*const array)[array_size]{
      reinterpret_cast<int32_t(*)[array_size]>(new int32_t[array_size])};
#endif
  size_t counter{array_size};
  for (auto &i : *array) i = counter--;
  for (const auto &i : *array) std::cout << i << std::endl;
  delete[] array;
}
#endif

// Něco malinko rozumnějšího, konečně.
void e(const size_t array_size) {
  std::unique_ptr<int32_t[]> array{new int32_t[array_size]};
  const int32_t *const array_end{array.get() + array_size};
  size_t counter{array_size};
  for (int32_t *p = array.get(); p < array_end; ++p) *p = counter--;
  for (const int32_t *p = array.get(); p < array_end; ++p)
    std::cout << *p << std::endl;
}  // Ha! Tady se to samo dealokuje.

// Kombinace předchozích rádoby-poznatků:
void f(const size_t array_size) {
  std::unique_ptr<int32_t[]> array{new int32_t[array_size]};
  size_t counter{array_size};
  for (auto &i : *reinterpret_cast<int32_t(*)[array_size]>(array.get()))
    i = counter--;
  for (auto i : *reinterpret_cast<int32_t(*)[array_size]>(array.get()))
    std::cout << i << std::endl;
}  // Pche! Nemusí se nic explicitně dealokovat!

// Tak. A teď konečně standardní (kni)hovna bez zbytečných nesmyslů.
void g(const size_t array_size) {
  std::vector<int32_t> array(array_size);  // () místo {}? Úkol pro čtenáře!
  size_t counter{array_size};
  for (auto &i : array) i = counter--;
  for (auto i : array) std::cout << i << std::endl;
}  // Žádná explicitní dealokace; Ředitel Vesmíru se postará.

}  // namespace

int main() {
  std::cout << "Malost pole: ";
  size_t array_size;
  std::cin >> array_size;
  if (std::cin.fail() || std::cin.get() != '\n') {
    std::cerr << "Hovno, vole.\n";
    return 1;
  }
  a(array_size);
  b(array_size);
  c(array_size);
#ifdef __GNUC__
  d(array_size);
#endif
  e(array_size);
  f(array_size);
  g(array_size);
  return 0;
}