Function Overloading C++: Nama Sama, Parameter Berbeda

Satu Nama, Banyak Versi

Kamu sering butuh operasi yang sama untuk jenis data yang berbeda: mencetak int, mencetak string, mencetak double. Di beberapa bahasa kamu harus membuat printInt, printString, printDouble. C++ membiarkanmu memberi semuanya nama yang sama dan membedakannya berdasarkan parameternya. Itulah function overloading.

Aturannya sederhana: beberapa fungsi boleh memakai satu nama asalkan daftar parameternya berbeda, baik dalam jumlah parameter, tipe, maupun urutannya. Compiler melihat argumen di setiap tempat pemanggilan dan memilihkan versi yang cocok untukmu.

#include <iostream>
#include <string>
using namespace std;

void print(int x) {
    cout << "int: " << x << "\n";
}

void print(double x) {
    cout << "double: " << x << "\n";
}

void print(const string& x) {
    cout << "string: " << x << "\n";
}

int main() {
    print(42);          // int: 42
    print(3.14);        // double: 3.14
    print(string("hi")); // string: hi
}

Tiga fungsi, satu nama. Setiap pemanggilan jatuh ke versi yang tipe parameternya sesuai dengan argumennya. Inilah yang membuat std::cout << x berfungsi untuk int, double, maupun string: operator<< di-overload berkali-kali.

Apa yang Dihitung sebagai Overload Berbeda

Sebuah overload dibedakan hanya dari daftar parameternya. Kamu bisa memvariasikan:

int  area(int side);                 // 1 param
int  area(int width, int height);    // 2 params  -> different
double area(double r);               // different type -> different

void log(string msg, int level);     // order matters...
void log(int level, string msg);     // ...so this is different too

Masing-masing adalah overload yang sah dan berbeda. Compiler menyusun kumpulan kandidat dari semua fungsi bernama area, lalu mencocokkannya berdasarkan jumlah dan tipe argumen.

Tipe Kembalian Saja Tidak Cukup

Inilah jebakan yang menjebak hampir semua orang: kamu tidak bisa melakukan overload berdasarkan tipe kembalian. Nilai kembalian tidak berperan dalam memilih overload, karena compiler menentukan fungsi mana yang dipanggil dari argumen-nya, sebelum ia melihat apa yang dikembalikan.

int    convert(double x);   // OK
double convert(double x);   // ERROR: redefinition - only the return type differs

Kode itu tidak akan bisa dikompilasi. Kalau daftar parameternya identik, kedua deklarasi itu dianggap fungsi yang sama dalam urusan overloading, dan kamu mendapat error redefinition. Untuk membedakan berdasarkan tipe hasil, ubah salah satu parameter (atau pakai template / type cast di tempat pemanggilan).

Cara Overload Resolution Memilih Pemenang

Saat kamu melakukan pemanggilan, compiler memeringkat setiap overload yang memungkinkan dan memilih kecocokan terbaik. Secara garis besar, urutan yang diutamakannya adalah:

1. Kecocokan persis (tanpa konversi).
2. Promosi (misalnya char atau short -> int, float -> double).
3. Konversi standar (misalnya int -> double, double -> int, pointer ke base).

Kalau tepat satu overload lebih baik daripada semua yang lain, dialah pemenangnya. Perhatikan bagaimana kecocokan persis mengalahkan konversi:

#include <iostream>
using namespace std;

void show(int x)    { cout << "int version\n"; }
void show(double x) { cout << "double version\n"; }

int main() {
    show(5);     // int version  (exact match)
    show(5.0);   // double version (exact match)
    show('A');   // int version  ('A' promotes char -> int)
}

'A' adalah char, tetapi promosi ke int peringkatnya lebih tinggi daripada konversi ke double, jadi yang dipanggil adalah overload int. Aturan peringkat inilah yang membuat overload resolution biasanya "langsung benar", dan sesekali mengejutkanmu.

Jebakan Ambiguitas

Kalau dua overload sama bagusnya, tidak ada yang lebih baik, compiler menolak menebak dan melaporkan ambiguous call. Contoh buku teksnya adalah dua overload yang masing-masing butuh konversi dengan peringkat yang sama:

void f(int x);
void f(double x);

f(0L);   // ERROR: ambiguous - long -> int and long -> double are equal-rank conversions

Baik int maupun double bukan kecocokan persis untuk long, dan kedua konversinya berada di peringkat yang sama, jadi pemanggilannya ambigu. Ada dua perbaikan yang rapi:

#include <iostream>
using namespace std;

void f(int x)    { cout << "int\n"; }
void f(double x) { cout << "double\n"; }

int main() {
    f(static_cast<int>(0L));  // disambiguate with a cast -> int
    // or add an exact-match overload like  void f(long)  to win outright
}

Kejutan yang serupa: meneruskan string literal. void g(const string&) dan void g(bool) sama-sama bersaing untuk g("hi"), dan bool bisa menang, karena const char* dikonversi ke bool (bukan null -> true) dengan langkah yang lebih sedikit daripada membangun std::string. Kalau kamu melihat string literal secara misterius memanggil overload bool-mu, inilah alasannya. Tambahkan overload const char* atau const string& supaya ada yang cocok persis.

Overloading dan Argumen Default Tidak Cocok Dicampur

Argumen default bukan pengganti overloading, dan menggabungkan keduanya menimbulkan ambiguitas. Keduanya bisa menjawab pemanggilan yang sama, sehingga compiler tidak bisa memilih:

void connect(string host, int port = 8080);   // can be called with 1 arg
void connect(string host);                     // also callable with 1 arg

connect("localhost");   // ERROR: ambiguous - both match a single argument

Pilih satu cara untuk setiap bentuk pemanggilan. Pakai argumen default saat perilakunya identik dan kamu hanya ingin parameter yang opsional; pakai overloading saat daftar argumen yang berbeda memang harus menjalankan kode yang benar-benar berbeda. Mencampur keduanya sehingga dua signature bertabrakan untuk jumlah argumen yang sama pasti menghasilkan error ambiguitas.

Satu perbedaan lagi yang perlu dipahami betul: overloading bukan overriding. Overloading ditentukan saat kompilasi, di antara fungsi-fungsi dalam scope yang sama dengan nama yang sama tetapi parameter berbeda. Overriding menggantikan fungsi virtual di class turunan saat program berjalan dan membutuhkan signature yang sama, topik yang dibahas di virtual function nanti.

Berikutnya: Lambda

Overloading memberi satu nama beberapa implementasi bertipe yang dipilih saat kompilasi. Namun kadang kamu sama sekali tidak ingin fungsi bernama: kamu butuh fungsi kecil sekali pakai yang didefinisikan tepat di tempat kamu memakainya, sering kali untuk diteruskan ke algoritma seperti sort. Persis itulah lambda: fungsi anonim yang bisa kamu tulis inline, bisa menangkap variabel di sekitarnya, dan bisa kamu serahkan dalam satu ekspresi. Berikutnya kita akan melihat cara menulisnya dan kapan lambda lebih unggul daripada fungsi bernama yang lengkap.