Rilis GCC 14: Fitur-Fitur Baru di Front End C++

Posted on by syauqi wiryahasana

Pada tanggal 7 Mei 2024, versi utama terbaru dari GNU Compiler Collection (GCC), yaitu GCC 14.1, telah resmi dirilis. Seperti setiap rilis utama GCC, versi ini membawa banyak penambahan, peningkatan, perbaikan bug, dan fitur baru. GCC 14 sudah menjadi compiler sistem di Fedora 40. Pengguna Red Hat Enterprise Linux (RHEL) akan mendapatkan GCC 14 di Red Hat GCC Toolset (RHEL 8 dan RHEL 9), dan sebagai compiler sistem di RHEL 10. Anda juga bisa mencoba GCC 14 di Compiler Explorer dan halaman serupa lainnya.

Seperti artikel sebelumnya yang membahas tentang GCC 13, artikel ini hanya menjelaskan fitur-fitur baru yang diimplementasikan di front end C++; tidak membahas perkembangan dalam bahasa C++ itu sendiri yang akan dijelaskan dalam posting blog terpisah. Perubahan menarik dalam pustaka standar C++ yang datang dengan GCC 14 juga akan dijelaskan dalam posting blog terpisah.

Dialek Default dan Eksperimental

Dalam GCC 14, dialek default masih -std=gnu++17. Anda bisa menggunakan opsi baris perintah -std=c++23 atau -std=gnu++23 untuk mengaktifkan fitur-fitur C++23, dan serupa untuk C++26 dan lainnya. Perlu dicatat bahwa fitur-fitur C++20, C++23, dan C++26 masih bersifat eksperimental di GCC 14.

Fitur-Fitur C++26

Trivial Infinite Loops dan Undefined Behavior

Proposal ini mendekatkan C dan C++ sedikit lebih dekat. Standar C++, tidak seperti standar C, mendefinisikan progress ke depan sedemikian rupa sehingga diasumsikan bahwa bahkan loop tak terbatas trivial akan akhirnya berakhir; jika tidak, program memicu perilaku yang tidak terdefinisi. Ini menjadi masalah jika Anda menulis kode tingkat rendah di mana loop tak terbatas seperti itu umum. Proposal ini menambahkan definisi dari pernyataan iterasi trivial kosong, di mana loop yang ekspresi pengendaliannya adalah ekspresi konstan yang mengevaluasi ke true adalah loop tak terbatas trivial; ini sekarang termasuk dalam definisi progress ke depan. Misalnya, dalam GCC 14, snippet berikut tidak lagi menyebabkan perilaku yang tidak terdefinisi (dalam semua dialek C++, bukan hanya C++26):

cppCopy codevoid g () {
  while (true)
  /* do something */;
}

Penyimpanan Statis untuk Braced Initializers

Proposal ini, yang diimplementasikan dalam GCC 14, memungkinkan compiler untuk mengoptimalkan kode yang menggunakan std::initializer_list dengan lebih baik. Implementasi dari std::initializer_list menggunakan array cadangan untuk datanya. Sebelum proposal ini, standar tidak mengizinkan compiler untuk mengalokasikan array cadangan dalam penyimpanan statis bahkan ketika isinya adalah data konstan karena semua array cadangan harus berbeda. Jadi compiler tidak punya pilihan selain menyalin data dari memori hanya-baca ke stack setiap kali list digunakan. Persyaratan ini tidak lagi diwajibkan oleh standar, oleh karena itu array cadangan bisa dibagi (yang sudah terjadi untuk string-literals). Singkatnya, GCC 14 mengoptimalkan panggilan memcpy yang menyalin array cadangan dalam snippet berikut:

cppCopy code#include <initializer_list>
void f(std::initializer_list<int> il);
void g() {
   f({3, 2, 1, 0, 1, 2, 3}); // array in .rodata
}

String Tidak Dievaluasi

GCC 14, dalam mode C++26, mengimplementasikan P2361R6 yang menambahkan konsep string tidak dievaluasi. String tidak dievaluasi muncul dalam konteks seperti _Pragma, static_assert, atau atribut [[nodiscard]] dan [[deprecated]]. String-string ini tidak digunakan dalam program saat runtime, jadi mereka tidak dikonversi ke encoding eksekusi seperti string yang dievaluasi. Karena mereka tidak akan dikonversi ke encoding string yang berbeda, mereka tidak bisa mengandung urutan pelolosan numerik, dan mereka tidak bisa memiliki prefix apapun. Dalam praktiknya, ini berarti bahwa dua baris berikut akan menyebabkan diagnostik yang dikeluarkan dalam mode C++26:

cppCopy codestatic_assert (true, u"foo"); // error in C++26
static_assert (true, "\x{20}"); // warning in C++26 in pedantic mode

Cast Constexpr dari void*

GCC 14 mengimplementasikan P2738R1, sehingga tes berikut diterima dalam C++26. Fitur ini memungkinkan pengguna untuk melakukan berbagai trik penghapusan tipe dalam kode constexpr. (Dalam C++23 dan sebelumnya, compiler masih mengeluarkan error tentang mencoba melakukan cast dari void* dalam ekspresi konstan.)

cppCopy codestruct A { int i; };
struct B { A a; };
constexpr int f() {
  B b { 42 };
  void *p = &b;
  A* ap = static_cast<A*>(p); // OK
  return ap->i;
}
static_assert (f() == 42);

Pesan Static_assert yang Dibuat Pengguna

Dengan proposal ini yang diimplementasikan dalam GCC 14, pengguna diperbolehkan menggunakan static_assert lebih umum karena sekarang juga menerima pesan yang dibuat oleh pengguna (yang secara jelas dievaluasi sebagai konstan). Misalnya:

cppCopy codestruct error {
  constexpr int size () const { return sizeof "hello" - 1; }
  constexpr const char *data () const { return "hello"; }
};
static_assert (false, error{});

Memberikan pesan error berikut:

cppCopy codeerror: static assertion failed: hello

Variabel Placeholder

GCC 14 mengimplementasikan proposal P2169R4. Proposal ini memungkinkan pengguna menggunakan variabel khusus _ yang berfungsi sebagai placeholder untuk variabel yang tidak bernama yang tidak akan menghasilkan diagnostik “unused variable” bahkan ketika tidak digunakan. _ juga bisa mendefinisikan ulang deklarasi yang ada dalam scope saat ini (tetapi sebenarnya menggunakan _ akan memicu error jika lebih dari satu variabel telah dideklarasikan dengan nama itu):

cppCopy codeX foo ();
void g () {
  auto _ = foo ();
  auto _ = 42;       // OK
  int i = _;         // error: reference to ‘_’ is ambiguous
}

Mengembalikan Referensi ke Sementara

P2748R5 membuatnya menjadi ill-formed untuk mengembalikan referensi ke sementara. GCC telah memperingatkan tentang kode berbahaya seperti itu sejak lama, tetapi C++26 membuatnya menjadi error.

cppCopy codeauto&& foo () {
  return 42;  // ill-formed in C++26
}

Fitur-Fitur C++23

Deducing This

GCC 14 mengimplementasikan proposal ini, yang banyak diminta oleh pengguna. Ini memungkinkan pengguna menambahkan parameter this eksplisit ke fungsi anggota non-statis; ini disebut parameter objek eksplisit. Dengan cara ini, Anda bisa menyimpulkan tipe dan kategori nilai dari objek kelas. Ini berguna untuk menghindari duplikasi kode; sebelumnya, pengembang terpaksa menulis beberapa overload fungsi anggota: non-const, const, dan dengan ref-qualifiers bahkan const & dan && (ini mengabaikan volatile dan sejenisnya). Dengan proposal ini, alih-alih:

cppCopy codeclass S {
  int value;
public:
  int get_add (int i) & { return value + i; }
  int get_add (int i) && { return value + i; }
  int get_add (int i) const & { return value + i; }
};
auto g (S s, const S& sr) -> int {
  auto i1 = s.get_add (42);
  auto i2 = sr.get_add (42);
  auto i3 = S{}.get_add (42);
  return i1 + i2 + i3;
}

Anda bisa menyederhanakan kode menjadi:

cppCopy codeclass S {
  int value;
public:
  template<typename Self>
  int get_add (this Self&& self, int i) { return self.value + i; }
};
S s{};
s.get_add(1);                // Self is deduced as S&
std::move(s).get_add(2);     // Self is deduced as S
std::as_const(s).get_add(3); // Self is deduced as const S&

Deducing this juga memungkinkan Anda menulis lambda rekursif. Misalnya:

cppCopy codeint main () {
  auto fib = [](this auto self, int n) {
    if (n < 2)
      return n;
    return self (n - 1) + self (n - 2);
  };
  static_assert (fib (6) == 8);
}

Ada banyak contoh lain di mana parameter objek eksplisit bisa berguna. Secara alami, fitur ini memiliki beberapa batasan; misalnya, fungsi anggota dengan objek eksplisit tidak bisa statis atau virtual.

Referensi dalam Ekspresi Konstan

Cara modern C++ untuk mengimplementasikan fungsi untuk mendapatkan ukuran array bisa menjadi:

cppCopy codetemplate<typename T, size_t N>
constexpr auto array_size (T (&)[N]) -> size_t {
  return N;
}

Fungsi ini bisa digunakan seperti dalam contoh kode ini:

cppCopy codevoid g () {
  int arr[] = { 1, 3, 3, 7 };
  constexpr auto sz = array_size (arr);
}

Kode ini bekerja tanpa masalah di GCC 13 dan sebelumnya, tapi tidak dalam fungsi constexpr, atau dalam static_assert. Sebelumnya, standar tidak mengizinkan menyimpan referensi ke objek yang tidak constexpr dalam ekspresi konstan. Sebagai contoh, GCC 13 dan sebelumnya tidak menerima:

cppCopy codetemplate<typename T, size_t N>
constexpr auto array_size (T (&)[N]) -> size_t {
  return N;
}
constexpr int arr[] = { 1, 3, 3, 7 };
static_assert (array_size (arr) == 4);

GCC 14 mengimplementasikan proposal P2266R1, yang memperluas ruang lingkup ekspresi konstan dengan referensi ke variabel bukan konstan yang sah untuk objek yang dievaluasi pada waktu kompilasi. Terima kasih pada proposal ini, kode sebelumnya sekarang diterima di GCC 14.

if consteval

Ini adalah proposal yang agak eksotis yang bisa membuat kode Anda lebih mudah dipahami dan lebih cepat dieksekusi. GCC 14 mengimplementasikan P1938R2. Anda bisa berpikir tentang if consteval sebagai perluasan dari if constexpr. Namun, if constexpr bekerja dengan parameter template dan mengevaluasi kondisi pada waktu kompilasi sementara if consteval beroperasi pada hasil ekspresi konstan. Singkatnya, if consteval memungkinkan Anda untuk membuat dua set implementasi untuk satu fungsi: satu set untuk waktu kompilasi, dan satu lagi untuk waktu runtime. Misalnya:

cppCopy code#include <cassert>
consteval int sq (int x) {
  return x * x;
}
constexpr int sq_ce (int x) {
  if consteval {
    return sq (x);
  } else {
    return x * x;
  }
}
void test () {
  constexpr int r = sq_ce (3); // uses consteval function sq
  assert (r == 9);
  int rr = sq_ce (3); // uses normal multiplication
  assert (rr == 9);
}

[[no_unique_address]] untuk Union

Atribut [[no_unique_address]] memungkinkan compiler mengoptimalkan alokasi ruang untuk anggota data yang tidak digunakan. Sebelum C++23, atribut ini tidak bisa digunakan dengan union. GCC 14 mengimplementasikan P0840R2, yang memungkinkan pengguna untuk mendeklarasikan union seperti ini:

cppCopy codestruct U {
  [[no_unique_address]] union {
    int i;
    float f;
  };
};

Atribut [[assume]]

Atribut ini mengizinkan pengguna untuk menambahkan pernyataan yang harus dipatuhi oleh compiler. Misalnya:

cppCopy code[[assume (sizeof (int) == 4)]]
void g ();

Dalam mode gualang seperti -Og atau -O1, GCC mengabaikan atribut ini. Pada optimisasi yang lebih tinggi, GCC mengasumsikan atribut ini benar dan mengoptimalkan kode berdasarkan asumsi tersebut.

Fitur-Fitur C++20

Atribut [[no_unique_address]] untuk Peringatan Duplicated

Dalam GCC 13 dan sebelumnya, pengguna bisa mendeklarasikan dua atau lebih objek dengan atribut [[no_unique_address]] tanpa menerima peringatan atau error. Namun, GCC 14 mengubah hal ini. Dalam mode C++20 dan yang lebih baru, memiliki lebih dari satu objek dengan atribut ini sekarang mengeluarkan peringatan:

cppCopy codestruct S {
  [[no_unique_address]] int x;
  [[no_unique_address]] int y; // warning: multiple [[no_unique_address]] members
};

Fitur-Fitur Lainnya

Selain fitur-fitur utama di atas, GCC 14 juga membawa beberapa perbaikan dan penambahan kecil lainnya yang mencakup berbagai area. Beberapa di antaranya adalah:

  • Standar dan Diagnostik: Perbaikan pada diagnostik yang dihasilkan untuk kasus-kasus tertentu, serta penyelarasan dengan standar yang lebih ketat untuk beberapa fitur bahasa.
  • Optimasi: Peningkatan pada pengoptimalan yang diterapkan pada berbagai skenario, yang membantu meningkatkan kinerja kode yang dihasilkan.

Kesimpulan

GCC 14 membawa banyak fitur baru yang memperkaya kemampuan bahasa C++. Dari penyempurnaan di area progress ke depan hingga pengenalan fitur seperti deducing this dan if consteval, rilis ini memberikan banyak alat baru bagi pengembang untuk menulis kode yang lebih efisien dan mudah dibaca. Mengikuti perkembangan GCC dan mengadopsi versi baru ini dapat membantu memastikan bahwa aplikasi Anda memanfaatkan kemampuan terbaru dari bahasa C++.