Makefile yang kita buat pada Chapter lalu jujur dan andal, tetapi ia terikat pada satu dunia: make di sistem Unix. Saat rekan satu tim memakai Windows dengan Visual Studio, atau macOS dengan Ninja, Makefile kita tidak bisa dipakai — dan menulis versi build file untuk setiap platform adalah pekerjaan yang tidak pernah selesai. CMake lahir persis untuk masalah ini: kita mendeskripsikan proyek sekali dalam file bernama CMakeLists.txt, dan CMake yang menghasilkan build system native untuk platform apa pun yang menjalankannya. Ia kini menjadi standar de facto ekosistem C++ — hampir semua library open source menyediakan integrasi CMake — sehingga dua chapter berikutnya beserta seluruh section dependency akan memakainya sebagai bahasa bersama. Satu catatan jujur sebelum mulai: lingkungan praktikum course ini belum memasang CMake, jadi pada Chapter ini kita belajar arsitekturnya dengan contoh yang ditampilkan, bukan dieksekusi — pendekatan yang berubah kembali ke eksekusi nyata begitu kita menyentuh bagian yang tersedia di sandbox.

Arsitektur: Generator, Bukan Compiler #

Kesalahpahaman paling umum tentang CMake adalah menganggapnya compiler atau pengganti make. Keduanya keliru. CMake adalah generator: alat yang membaca deskripsi proyek lalu menuliskan build system native — Makefile di Linux, file proyek Ninja, atau file solusi Visual Studio di Windows. Alur kerjanya dua fase:

Fase pertama (configure) membaca CMakeLists.txt, memeriksa compiler yang tersedia, dan menuliskan build file ke dalam folder build. Fase kedua (build) sebenarnya sudah bukan urusan CMake — kita memanggil make atau Ninja seperti biasa, dan tugas CMake berakhir setelah build file jadi. Karena deskripsi proyeknya netral platform, satu CMakeLists.txt melayani developer Linux, macOS, dan Windows tanpa diubah.

Konvensi penting yang menyertai alur ini adalah out-of-source build: semua hasil — build file, object file, executable — ditempatkan di folder build/ yang terpisah dari source code. Folder source tetap bersih, dan membersihkan seluruh hasil build cukup menghapus satu folder.

CMakeLists.txt Minimal #

Cukup tiga baris untuk proyek satu file. Program contohnya sendiri sudah diuji nyata di lingkungan praktikum:

cpp 
#include <iostream>

double luasSegitiga(double alas, double tinggi) {
    return alas * tinggi / 2.0;
}

int main() {
    std::cout << "Kalkulator luas segitiga\n";
    std::cout << "Luas 6 x 4  = " << luasSegitiga(6.0, 4.0) << "\n";
    std::cout << "Luas 10 x 3 = " << luasSegitiga(10.0, 3.0) << "\n";
    return 0;
}

Output yang Dihasilkan:

text 
Kalkulator luas segitiga
Luas 6 x 4  = 12
Luas 10 x 3 = 15

Dan inilah deskripsi proyeknya — disimpan sebagai CMakeLists.txt di folder yang sama dengan kalkulator.cpp:

cmake CMakeLists.txt 
cmake_minimum_required(VERSION 3.16)
project(Kalkulator LANGUAGES CXX)

add_executable(kalkulator kalkulator.cpp)

Tiga baris, tiga pekerjaan. Baris pertama menuntut versi CMake minimum — pelindung agar fitur yang kita pakai tidak dijalankan di CMake yang terlalu tua. Baris kedua menamai proyek dan menyatakan bahasanya. Baris ketiga memuat semua logika: buat target executable bernama kalkulator dari source kalkulator.cpp — konsep target yang kita dalami pada Chapter CMake Targets.

Alur Kerja di Terminal #

Dengan CMake terpasang, membangun proyek tadi berarti dua perintah. Berikut bentuk khas perintah dan keluarannya — ditampilkan sebagai contoh dari mesin yang memasang CMake, karena detail angka waktu dan path memang berbeda antar mesin:

bash 
cmake -B build
cmake --build build
./build/kalkulator
text 
-- The CXX compiler identification is GNU 14.2.0
-- Check for working CXX compiler: /usr/bin/g++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: .../build

Perintah cmake -B build menjalankan fase configure ke folder build (baris -- adalah laporan pemeriksaan compiler), dan cmake --build build adalah pintu masuk generik yang di balik layar memanggil build system native hasil configure — make di mesin ini, Ninja atau Visual Studio di mesin lain. Manfaatnya praktis: perintah build kita identik di semua platform, meski isinya berbeda.

Bandingkan dengan proses di Chapter Make dan Makefile: kita tidak lagi menulis daftar file .o dan aturan -c — CMake yang menuliskannya, dan kita tetap bisa membuka build/Makefile hasil generate-nya untuk melihat apa yang sebenarnya akan dijalankan.

Memasang CMake #

CMake tidak ikut terpasang bersama compiler. Tiga jalan paling umum:

  • Debian/Ubuntu: sudo apt install cmake — cara tercepat, versinya mengikuti repositori distro.
  • Pengunduhan resmi: installer atau arsip dari laman unduhan CMake di situs cmake.org — cocok bila Anda butuh versi terbaru di mana pun.
  • Manajer paket lain: brew install cmake di macOS, atau versi portable yang tinggal diekstrak dan masukkan foldernya ke PATH.

Sesudah terpasang, satu perintah memastikan semuanya siap — keluarannya berupa nomor versi, misalnya cmake version 3.28.3:

bash 
cmake --version

Dengan arsitektur dan alurnya di kepala, kita sudah siap menulis CMakeLists yang lebih berdaging: proyek nyata punya lebih dari satu target, saling berhubungan, dan butuh pengaturan per-target — semuanya bahasa bawaan CMake yang kita bedah pada Chapter berikutnya.

Referensi: Dokumentasi CMake .