C++ ve Function Overloading

Bu konunun amacı; programcıların kod yazarken daha esnek davranabilmesine ve kodun okunurluğunu artırmasına katkı sağlamaktır. Kullanım yöntemi olarak aynı isimle ancak farklı imzalara(farklı parametre/ler) sahip birden fazla fonksiyon(diğer dillerde method olarak geçebilir) tanımlayabilme kabiliyetidir. Bu fonksiyonlar farklı türlerle kullanılabilirken aynı isim kullanılıp benzer işlevleri guruplamaya imkan vermektedir.

Tabi bunu yaparken şunları maddeler halinde sıralamak daha anlaşılır olmasını sağlayabilir :

1. Bu aynı isimle kullanılan fonksiyonlar aynı scope içerisinde olmalıdır.(scope, name lookup ve context control konularına da değinilecektir)

2. Fonksiyonların imzaları kesinlikle farklı olmalıdır.(parametrelerin sayısı ve/veya türü farklı olmalıdır)

3. Bu durumda early binding(static binding) yani derleme zamanında fonksiyon çağrılarının çalıştırılacak fonksiyonu belirleme yapacağını ifade edebilmekteyiz. Performans artışı yani run-time maliyetinin azaltılması da bunun çıktısı olarak düşünülebilir.

4. Üçüncü maddenin özeti olarak çalışma zamanı maliyeti yoktur.

5. Dikkat edilmesi gereken noktalardan önemli olanları redecleration, viable function ve ambiguity durumlarıdır.

int smart_code(float);
int smart_code(float, float);
*****************************
AÇIKLAMA : Bu durum aynı isimli imzaları fonksiyonları yani function overloading durumunu ifade etmektedir.
*****************************

void smart_code(int* ptr);
void smart_code(const int* ptr);
*****************************
AÇIKLAMA : low level const ve aynı isimli imzaları fonksiyonları yani function overloading(const overloading) durumunu ifade etmektedir.
*****************************

int smart_code(int);
double smart_code(int);
*****************************
AÇIKLAMA : aynı isimli ancak imzaları da aynı yani function overloading durumunu ifade etmemektedir.!!!
*****************************

int smart_code(int);
int smart_code(int);
*****************************
AÇIKLAMA : aynı isimli ancak imzaları da aynı yani function overloading durumunu ifade etmemektedir ve bu durum redeclaration olarak ifade edilir!!!
*****************************

void smart_code(int* ptr);
void smart_code(int* const ptr);
*****************************
AÇIKLAMA : top level const ve bu durum redeclaration olarak ifade edilir!!!
*****************************

void smart_code(char);
void smart_code(unsigned char);
void smart_code(signed char);
*****************************
AÇIKLAMA : türlerin her biri distinct(benzersiz) türler olduğu için birbirleriyle overload durumunu oluşturmaktadırlar. 
*****************************

void smart_code(int val);
void smart_code(int16_t val);
*****************************
AÇIKLAMA : int16_t türü typedef bildirimidir ve function overloading durumu derleyiciye bağımlıdır.
*****************************

void smart_code(int);
void smart_code(bool);
*****************************
AÇIKLAMA : bool ve int türleri farklı türlerdir ve önceki yazılarda bool türünün c++ dilindeki durumu anlatılmıştır. Burada int ve bool türleri overload oluşturmaktadırlar.
*****************************

void smart_code(int val);
void smart_code(int val = 5);
*****************************
AÇIKLAMA : ikinci fonksiyonda default argument durumu vardır ancak bu durum function overloading olarak değerlendirilmez.!!!
*****************************

void smart_code(int val);
void smart_code(int& val);
*****************************
AÇIKLAMA : reference durumu da function overloading olarak değerlendirilmektedir.
*****************************

void smart_code(int& val);
void smart_code(int&& val);
*****************************
AÇIKLAMA : R value ve L value reference durumu da function overloading olarak değerlendirilmektedir.
*****************************

Function Overload Resolution : Fonksiyonların aşırı yüklenmesinin çözümlenmesidir yani birden fazla ve aynı isimli fonksiyonlardan hangisinin çağırılacağının bulunması sürecidir.

Ambiguity : Birden fazla fonksiyon arasında seçim sürecinde derleyicinin karar verememe durumudur. Yani çağrının ilgili fonksiyonlardan hiçbirine uygun olmamasıdır.

Viable : Bir fonksiyon çağrısının, dilin kurallarına uygun bir şekilde derlenebilecek ve çağrılabilecek bir function overloading adayı olduğunu ifade eder.

Çağırılan Fonksiyonlar Kontrol Edilirken :

1. Çağrı ilgili fonksiyonun parametre sayısı ile eşdeğer olmalıdır. (default argüman ve variadic function hariç)

2. Çağrı ile otomatik tür dönüşümüne uygun olmalıdır.

Birden fazla parametreli overload olan fonksiyonların olması durumunda :

1. Standartlarda overload fonksiyonlara çağrı yapıldığında bir fonksiyonun ambiguity olmadan seçilebilmesi için en az bir parametrede diğerlerine üstünlük sağlaması gerekmektedir.

2. Diğer parametrelerde de daha düşük olmayacak eşit olabilecektir.

void smart_code(int* val);

int main()
{
    void* vptr = nullptr;

    smart_code(vptr);
}
*****************************
AÇIKLAMA : smart_code çağrısı viable çağrı değildir çünkü void* to int* otomatik tür dönüşümü legal değildir.
*****************************

void smart_code(int);
void smart_code(double);

int main()
{    
    smart_code(5L);
}
*****************************
AÇIKLAMA : viable çağrıdır.
*****************************

void smart_code(long double);
void smart_code(char);

int main()
{    
    func(29.5);
}
*****************************
AÇIKLAMA : viable çağrıdır.
*****************************

int sum_array(const int s_arr[], int cnt) 
{
    int total{0};
    
    for (int i = 0; i < size; i++) 
    {
        total += s_arr[i];
    }
    
    return total;
}

double sum_array(const double s_arr[], int cnt) 
{
    double total{0.0};
    
    for (int i = 0; i < size; i++) 
    {
        total += s_arr[i];
    }
    
    return total;
}