C++ Dilinde Fonksiyon Çağrı Operatörünün Overload Edilmesi

C++ dilinde overload mekanizmasını anlatmaya operatörlerin overload edilmesile başlamıştık. Buna ait temek kuralları anlatarak örneklendirdik ve o yazımızda da fonksiyon çağrı operatöründen bahsetmiştik. Farklı senaryolar olabileceği için de ayrı bir başlık açmanın faydası olabilir.

SmartCode sc;
sc();	

Buradaki gibi sınıf türünden olan sc nesnesi fonksiyon çağrı operatörünün operandı olacak şekilde çağırılmış ve overload edilmiş ise derleyici tarafından bu overload edilen operatöre çağrı olarak algılanacaktır. Fonksiyon çağrı operatörünü overload eden böyle sınıflara "Functor class" denilmektedir. Ve ismiyle çağrı yapılabilmektedir.

Parametre değişkeni olmadan overload edilebilir.

class SmartCode {
public :
    void operator()()const                     
    {                                                                 
        cout << "SmartCode::operator()()this : " << this << endl;    
    }
};

int main() 
{
    SmartCode sc;

    cout << &sc << endl;
    sc();                                      
}
*****************************
AÇIKLAMA: SmartCode sınıfının içerisinde fonksiyon çağrı operatörü parametresiz void dönüşü olacak şekilde ve const olarak overload edilmiştir. Geri dönüş değeri int, double ... olabilir. const olması da tasarımcıya bağlıdır. Ve çağrı da parametresi olmadığı içinde sc() şeklinde çağrı yapılmıştır.
*****************************
CEVAP:
*****************************

Parametresi olan fonksiyon çağrı operatörü overload edilmesi...

class SmartCode {
public :
    void operator()(int val)const               
    {                                  
        cout << "SmartCode::operator()(int)val : " << val << endl; 
    } 

    void operator()(double dval)const                
    {                                   
        cout << "SmartCode::operator()(double)dval : " << dval << endl;  
    }
};

int main() 
{
    SmartCode sc;

    sc(10);
    sc(2.9);                                    
}
*****************************
AÇIKLAMA: SmartCode sınıfının içerisinde fonksiyon çağrı operatörü int ve double parametreli void dönüşü olacak şekilde ve const olarak overload edilmiştir. Geri dönüş değeri int, double ... olabilir. const olması da tasarımcıya bağlıdır. Ve çağrı da parametresi olmadığı içinde sc(int) ve sc(double) şeklinde çağrı yapılmıştır.
*****************************
CEVAP:
*****************************

Default parametre alan fonksiyon çağrı operatörü overload edilmesi..

class SmartCode {
public :
    void operator()(int val = 10)const                
    {                                   
        cout << "SmartCode::operator()(int)val : " << val << endl;  
    }
};

int main() 
{
    SmartCode sc;

    sc(10);
    sc();                                    
}
*****************************
AÇIKLAMA: SmartCode sınıfının içerisinde fonksiyon çağrı operatörü default parametreli void dönüşü olacak şekilde ve const olarak overload edilmiştir. Geri dönüş değeri int, double ... olabilir. const olması da tasarımcıya bağlıdır. Ve çağrı da parametresi olmadığı içinde sc() ve sc(double) şeklinde çağrı yapılmıştır. sc() şeklinde çağrıda default parametre olan 10 değeri baz alınacaktır.
*****************************
CEVAP:
*****************************

Yapılan çağrılar aslında overload edilen operatör adıyla yapılmış şekilde derleyici tarafından algılanır.

class SmartCode {
public :
    void operator()()const                     
    {                                                                 
        cout << "SmartCode::operator()()" << endl;    
    }
};

int main() 
{
    SmartCode sc;

    sc.operator()();                                      
}
*****************************
AÇIKLAMA: sc() çağrısıyla sc.operatör()() çağrıları aynıdır.
*****************************
CEVAP:
*****************************

#include <iostream>

using namespace std;

class SmartCode { 
public : 
    void operator()(int val)const                
    {                                   
        cout << "SmartCode::operator()(int)val : " << val << endl;  
    }

    void operator ()(double dval)const                 
    {                                   
        cout << "SmartCode::operator()(double)dval : " << dval << endl;   
    } 
}; 

SmartCode func()
{
    return SmartCode{};
}

int main() 
{ 
    SmartCode sc; 
    
    func()(10); 
    func()(5.9);   
}
*****************************
AÇIKLAMA: fonksiyon çağrı operatörü nesneleri bir fonksiyon gibi çağırmaya olanak tanır. 
*****************************
CEVAP:
*****************************

Örnekler ...

#include <iostream>   
#include <cstdlib>

using namespace std; 

class SmartCode { 
private :
    int m_low, m_high; 
    
public : 
    SmartCode (int low, int high) : m_low{ low }, m_high{ high } {}

    int operator()() 
    { 
        return rand() % (m_high - m_low + 1) + m_low; 
    } 
};

void func(SmartCode rnd)  
{ 
    for (int i = 0; i < 5; ++i)  
    {  
        cout << rnd() << " ";  
    } 
}

int main()  
{ 
    SmartCode rnd1{ 10, 20 };      
    SmartCode rnd2{ 20, 40 };

    func(rnd1);
    
    cout << endl;
    
    for (int i = 0; i < 5; ++i)  
    { 
        cout << rnd1() << " "; 
    } 
     
    cout << endl;

    for (int i = 0; i < 5; ++i)  
    {  
        cout << rnd2() << " ";  
    } 
}
*****************************
AÇIKLAMA: 
*****************************
CEVAP:
*****************************

#include <iostream> 
#include <string> 
#include <vector> 
#include <algorithm> 

using namespace std;

class SmartCode { 
private :
    size_t m_len; 

public: 
    SmartCode(size_t len) : m_len{ len } {}

    bool operator()(const string& str) 
    { 
        return str.length() == m_len; 
    } 
};

int main() 
{                                      
    vector<string>svec{"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus"};
    cout << "num count : "; 
    size_t len; 
    cin >> len; 

    cout << count_if(svec.begin(), svec.end(), SmartCode{ len }) << endl; 
}
*****************************
AÇIKLAMA: 
*****************************
CEVAP:
*****************************