Setiap program C++ yang berhasil dijalankan selalu dimulai dari satu tempat yang sama: fungsi main(). Ketika kita menjalankan file executable, sistem operasi memanggil fungsi ini sebagai titik awal eksekusi. Karena itu, program C++ paling kecil pun tetap harus punya main() — tanpa dia, linker menolak menghasilkan executable. Pada Chapter ini kita membedah bentuk-bentuk main() yang legal, memahami arti return value yang dikembalikannya, dan mencoba bentuk lengkap yang menerima argumen dari terminal.

Pintu Masuk Setiap Program C++ #

Saat kita mengetik ./program di terminal, sistem operasi memuat file executable lalu menjalankan kode yang menempel pada fungsi main(). Eksekusi berjalan dari pernyataan pertama di dalam main() secara berurutan sampai program mencapai return atau mencapai akhir fungsi. Fungsi lain boleh ditulis dan dipanggil dari main() (akan kita pelajari pada Section Fungsi), tetapi alur program selalu bermula dari sini. Aturan pentingnya tegas: satu program hanya boleh memiliki satu main() global, dan kita tidak boleh memanggil main() sendiri dari dalam kode. Jika dua file sama-sama mendefinisikan main(), linker akan mengeluh tentang definisi ganda; jika tidak ada main() sama sekali, linker mengeluarkan pesan undefined reference to main.

Bentuk Paling Umum: int main() #

Bentuk yang akan paling sering kita tulis adalah int main() yang menerima tanpa parameter dan mengembalikan int. Berikut program lengkap dengannya, sudah diuji dari kompilasi sampai eksekusi:

cpp 
#include <iostream>

int main() {
    std::cout << "Program pertama kita berjalan!\n";
    std::cout << "Fungsi main() adalah pintu masuknya.\n";

    return 0;
}

Output yang Dihasilkan:

text 
Program pertama kita berjalan!
Fungsi main() adalah pintu masuknya.

Mari kita telaah baris demi baris:

  1. Baris 1 (#include <iostream>): preprocessor menyisipkan deklarasi input-output standar agar std::cout dikenal compiler. Pembahasan lengkapnya ada di Chapter berikutnya.
  2. Baris 4 (int main()): kata int di depan menyatakan tipe kembalian fungsi, yaitu bilangan bulat yang dilaporkan saat program selesai. Tanda () kosong berarti fungsi ini tidak menerima parameter apa pun.
  3. Baris 5-6: dua pernyataan mencetak teks ke terminal. Tubuh fungsi dibungkus { }, dan setiap pernyataan diakhiri titik koma.
  4. Baris 8 (return 0;): fungsi mengembalikan 0 ke pemanggilnya (sistem operasi) sebagai status akhir program.

Return Value: Melapor ke Sistem Operasi #

Return value main() disebut exit code, yaitu angka status yang diterima sistem operasi setelah program selesai. Konvensinya sederhana: 0 berarti program selesai dengan sukses, sedangkan nilai bukan nol menandakan ada kondisi khusus atau kegagalan. Nilai bukan nol ini kita tetapkan sesuai makna yang diinginkan, misalnya 1 untuk kesalahan umum atau 2, 3 untuk kondisi tertentu yang kita definisikan. Skrip shell dan alat otomasi (misalnya CI/CD) membaca angka ini untuk memutuskan apakah program berhasil atau perlu dihentikan.

Contoh berikut sengaja mengembalikan 3. Karena blok ini memakai atribut exit="3", pengujinya memeriksa exit code program, bukan isi output:

cpp 
#include <iostream>

// Return value main() dilaporkan ke sistem operasi sebagai exit code.
// Di sini kita mengembalikan 3 untuk menandai kondisi tertentu.
int main() {
    std::cout << "Memproses data...\n";
    std::cout << "Selesai dengan status khusus (exit code 3).\n";

    return 3;
}

Di terminal, kita bisa membaca exit code program terakhir lewat variabel khusus $?:

bash 
g++ -std=c++23 -Wall main-return.cpp -o main-return
./main-return
echo "Exit code: $?"

Perintah di atas mencetak dua baris output program, lalu Exit code: 3 — bukti bahwa return value benar-benar sampai ke shell. Header <cstdlib> juga menyediakan konstanta EXIT_SUCCESS dan EXIT_FAILURE bila kita ingin kode lebih mudah dibaca; keduanya bernilai 0 dan 1.

Menerima Argumen: int main(int argc, char* argv[]) #

Ada bentuk main() kedua yang standar: bentuk lengkap dengan dua parameter, int main(int argc, char* argv[]). Parameter argc (argument count) berisi jumlah argumen yang diberikan lewat terminal, sedangkan argv (argument vector) menyimpan argumen tersebut sebagai rangkaian C-string. argv[0] selalu berisi nama/path program itu sendiri, sehingga argumen buatan pengguna mulai dari argv[1]. Bentuk inilah yang dipakai tool baris perintah seperti g++ untuk membaca opsi dan nama file yang kita ketik.

cpp 
#include <iostream>

// Bentuk lengkap main(): menerima jumlah argumen dan daftar argumennya.
// Jalankan dengan dua argumen, misalnya: ./main-argumen Budi 21
int main(int argc, char* argv[]) {
    std::cout << "Jumlah argumen (argc): " << argc << "\n";
    std::cout << "Argumen pertama (argv[1]): " << argv[1] << "\n";
    std::cout << "Argumen kedua (argv[2]): " << argv[2] << "\n";

    return 0;
}

Output yang Dihasilkan:

text 
Jumlah argumen (argc): 3
Argumen pertama (argv[1]): Budi
Argumen kedua (argv[2]): 21

Yang perlu dicermati dari hasil di atas:

  • argc bernilai 3, bukan 2, karena argv[0] (path program) ikut terhitung.
  • Kita tidak mencetak argv[0] karena isinya adalah path executable yang berbeda di setiap komputer dan folder — program kita sebaiknya tidak bergantung pada hal yang berubah-ubah.
  • argv[1] dan argv[2] dicetak apa adanya sebagai teks; angka 21 di sini masih berupa C-string, bukan bilangan yang bisa dihitung (konversinya kita pelajari nanti).

Standar C++ menetapkan hanya dua bentuk main() yang dijamin portable: int main() dan int main(int argc, char* argv[]). Ada beberapa detail kecil yang legal sekelilingnya, dan mengetahuinya melindungi kita dari kode contoh lama yang tidak konsisten:

cpp 
// Legal: return 0 implisit — KHUSUS main(), fungsi lain tidak boleh
int main() {
    std::cout << "Tanpa return eksplisit\n";
}

// Legal: gaya C, sama artinya persis dengan int main()
int main(void) {
    return 0;
}

Bentuk pertama menarik: jika kita lupa menulis return, compiler otomatis menganggap main() mengembalikan 0. Pengecualian ini hanya berlaku untuk main(); fungsi lain yang tipe kembaliannya int tetap wajib mengembalikan nilai. Sebaliknya, void main() yang kadang muncul di tutorial lama tidak didefinisikan standar — compiler tertentu menerimanya, tetapi kode seperti itu tidak portable. Rangkuman aturan main() selengkapnya dapat dibaca pada halaman main function di cppreference.

Karena main() harus unik, kita tidak boleh mendefinisikannya di dua file yang dilink menjadi satu program, dan kita tidak boleh membuat fungsi bernama main lain di scope global. Dengan main() sudah jelas, langkah berikutnya adalah memahami baris paling atas dari hampir semua program C++: perintah #include yang membawa header ke dalam kode kita.