Рубрики

Какие операторы могут быть и не могут быть перегружены в C ++?

Список операторов, которые могут быть перегружены:

+    -    *    /      %        ^
&    |    ~    !,        =
    =      ++        --
    ==    !=      &&        ||
+=    -=    /=    %=      ^=        &=
|=    *=    =      []        ()
->    ->*    new    new []      delete    delete []

Пример 1: оператор перегрузки ++

// Программа CPP для иллюстрации
// операторы, которые могут быть перегружены
#include <iostream>

using namespace std;

  

class overload {

private:

    int count;

  

public:

    overload()

        : count(4)

    {

    }

  

    void operator++()

    {

        count = count + 1;

    }

    void Display()

    {

        cout << "Count: " << count;

    }

};

  

int main()

{

    overload i;

    // это вызывает функцию "function void operator ++ ()"

    ++i;

    i.Display();

    return 0;

}

Выход:

Count: 5

Эта функция вызывается, когда оператор ++ работает с объектом класса перегрузки (в данном случае это объект i). В программе определена операторная функция void operator ++ () (внутри класса перегрузки). Эта функция увеличивает значение count на 1 для объекта i.

Пример 2: оператор перегрузки ++ и оператор постинкремента перегрузки

// эта программа продемонстрирует
// Разница между прединкрементным и постперегрузочным оператором
#include <iostream> 

using namespace std; 

    

class overload { 

private

    int count; 

    

public

    overload(int i) 

        : count(i) 

    

    

    

    overload operator++(int

    

        return (count++); 

    }

    overload operator++()

    {

            count = count + 1;

            return count;        

    }

    void Display() 

    

        cout << "Count: " << count<<endl; 

    

}; 

  // Код драйвера

int main() 

    overload i(5); 

    overload post(5);

    overload pre(5);

      

    // это вызывает функцию "оператор перегрузки функции ++ ()"

    pre = ++i;

    cout<<"results of I   =   ";

    i.Display();

    cout<<"results of preincrement   =  ";

    pre.Display();

    // это вызов функции "оператор перегрузки функции ++ ()"

    i++;// просто чтобы показать разницу

    i++; // просто чтобы показать разницу

    post = i++;

    cout<<"Results of post increment   =   ";

    post.Display(); 

    cout<<"And results of i , here we see difference   :   ";

    i.Display();

    return 0; 

output:
results of I   =   Count: 6
results of preincrement   =  Count: 6
Results of post increment   =   Count: 8
And results of i , here we see difference   :   Count: 9

Пример 3: перегрузка этого оператора []

#include <iostream>

using namespace std;

class overload {

    int a[3];

  

public:

    overload(int i, int j, int k)

    {

        a[0] = i;

        a[1] = j;

        a[2] = k;

    }

    int operator[](int i)

    {

        return a[i];

    }

};

int main()

{

    overload ob(1, 2, 3);

    cout << ob[1]; // отображает 2

    return (0);

}

Выход:

2

Пример 4: Перегрузка -> оператор

// Программа CPP для иллюстрации
// операторы, которые могут быть перегружены
#include <bits/stdc++.h>

using namespace std;

  

class GFG {

public:

    int num;

    GFG(int j)

    {

        num = j;

    }

    GFG* operator->(void)

    {

        return this;

    }

};

  
// Код драйвера

int main()

{

    GFG T(5);

    GFG* Ptr = &T;

      

    // Доступ к num обычно

    cout << "T.num = " << T.num << endl; 

      

    // Доступ к num с помощью обычного указателя на объект

    cout << "Ptr->num = " << Ptr->num << endl; 

      

    // Доступ к num с помощью оператора ->

    cout << "T->num = " << T->num << endl; 

  

    return 0;

}
// Спасибо, Рохан Агарвал, за предложенный пример.

Выход :

T.num = 5
Ptr->num = 5
T->num = 5

Список операторов, которые не могут быть перегружены

1> Scope Resolution Operator  (::)    
2> Pointer-to-member Operator (.*)    
3> Member Access or Dot operator  (.)    
4> Ternary or Conditional Operator (?:) 
5> Object size Operator   (sizeof) 
6> Object type Operator   (typeid) 

Пример 5: перегрузка оператора. (Точка)

Оператор точки (.) Не может быть перегружен, поэтому он вызывает ошибку.

// C ++ программа для иллюстрации
// Перегрузка оператора. (Точка)
#include <iostream>
#include <iostream>

class cantover {

public:

    void fun();

};

class X { // предположим, что вы можете перегрузить.

    cantover* p;

    cantover& operator.()

    {

        return *p;

    }

    void fun();

};

void g(X& x)

{

    x.fun(); // X :: fun или cantover :: fun или error?

}

Выход

prog.cpp:8:27: error: expected type-specifier before '.' token
         cantover& operator.() 
                           ^
prog.cpp:8:19: error: expected ';' at end of member declaration
         cantover& operator.() 
                   ^
prog.cpp:8:27: error: expected unqualified-id before '.' token
         cantover& operator.() 
                           ^
prog.cpp: In function 'void g(X&)':
prog.cpp:13:14: error: 'void X::fun()' is private
         void fun();
              ^
prog.cpp:18:15: error: within this context
         x.fun();              // X::fun or cantover::fun or error?
               ^

Эта проблема может быть решена несколькими способами. Во время стандартизации не было очевидно, какой путь будет наилучшим.

Эта статья предоставлена Shivani Ghughtyal . Если вы как GeeksforGeeks и хотели бы внести свой вклад, вы также можете написать статью с помощью contribute.geeksforgeeks.org или по почте статьи contribute@geeksforgeeks.org. Смотрите свою статью, появляющуюся на главной странице GeeksforGeeks, и помогите другим вундеркиндам.

Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.

Рекомендуемые посты:

Какие операторы могут быть и не могут быть перегружены в C ++?

0.00 (0%) 0 votes