Оператор не имеет результата требуется оператор с побочным действием

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

Подпишись на группу Вконтакте и Телеграм-канал. Там еще больше полезного контента для программистов.
А на YouTube-канале ты найдешь обучающие видео по программированию. Подписывайся!

Перегрузка операторов в языке программирования C#

Перегрузка операций в С# похожа на переопределение методов. В языке С# в зависимости от типа оператора объявляется оно двумя способами.

// перегрузка унарного оператора
public static тип operator primer(тип_параметра операнд)
{
// запросы
}

// перегрузка бинарного оператора
public static тип operator primer (тип_параметра1 операнд1, тип_параметра1 операнд2)
{
// запросы
}

Метод объявляется модификаторами public и static. Оператор, который перегружается должен быть одного типа с операндами.

Во время перегрузки оператора его функция и свойство не теряется, он только выполняет еще одну операцию. К примеру, оператор + используется для работы со списком при этом его назначение к сложению целых чисел не меняется. Когда оператор + используется со строковыми данными, выполняется перегрузка оператора со стороны класса String.

В С# существует операторы «+», «-», «!», «==», «!=» и другие, которые предназначены для работы с типами данных.

Так как в языке программирования С# используются готовые алгоритмы базовых операций, в некоторых моментах важна перегрузка операторов. Например, когда используем оператор + для целых чисел он возвращает сумму чисел, а если использовать его для строковых типов данных тогда выполняется объединение двух строк.

string a = «Сергей «;
string b = «Сергеев»;
string c = a + b; //результат «Сергей Сергеев»

Перегрузка операторовпозволяет добавлять удобный синтаксис для работы с классом в среду программирования. Это возможность одна из сильных сторон объектно-ориентированного языка программирования С#.

Когда в классе присутствует перегруженный оператор, компилятор сначала выполняет поведение определенное пользователем, если не определено, то осуществляется стандартная реализация.

Перегрузка операторов С# делает код красивее. Мы задаем, редактируем, или сами можем придумывать поведение определенного нами класса. Используя унарные, бинарные операторы, операторы сравнения и логические операторы мы задаем определенное действие компилятору.

Например, есть класс «точки» с координатами х и у. Два целых числа, объединенные одним классом. Мы можем сложить эти две точки. Даже если компилятор умный, система не в состоянии понять какое сложение точек выполнить. Поэтому нужно перегружать оператор, чтобы объяснить компилятору, как системе себя вести и какое действие выполнить. Возможно системе нужно сложить между собой все х или же сложить все y. Компилятор может выполнить банальное сложение двух заданных точек, но, чтобы их выполнить, нужно указать поведение: например, когда нужно решать по формуле, для этого и служит перегрузка операторов. При ней пользователь С# задает правильное поведение, которое ожидается от класса.

class MyPoint
{
int х, у,z// три координаты
public MyPoint() { х = у = z = 0; }

// Перегрузить бинарный оператор +.
public static MyPoint operator +(MyPoint op1, MyPoint op2)
{
MyPoint result = new MyPoint();
/* Сложить координаты двух точек и возвратить результат. */
result.х = op1.x + ор2.х; // Эти операторы выполняют
result.у = op1.y + ор2.у; // целочисленное сложение,
result.z = op1.z + op2.z; // сохраняя свое исходное назначение.
return result;
}

// Перегрузить бинарный оператор -.
public static MyPoint1 operator -(MyPoint1 op1, MyPoint1 op2)
{
MyPoint1 result = new MyPoint1();
/* Обратите внимание на порядок следования операндов:
op1 — левый операнд, а ор2 — правый операнд. */
result.х = op1.x — ор2.х; // Эти операторы
result.у = op1.y — ор2.у; // выполняют целочисленное
result.z = op1.z — op2.z; // вычитание
return result;
}

// Вывести координаты X, Y, Z.
public void Show()
{
Console.WriteLine(x + «, » + у + «, » + z);
}
}

Когда оператор перегружается, выполняет заданные поведение. Но его первоначальное назначение не меняется.

Перегружаемые операторы

Эти операторы можно перегрузить:

1. Унарные операции +,  -,  !,  ++, — true, false;
2. Бинарные операции +,  -,  *,  /,  %,  &,  |,  ,<<,  >>;
3. Операции сравнения должны быть перегружены парами ==,  !=,<,  >,<=, >=.

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

// Перегрузить оператор >.
public static bool operator >(dot op1, dot op2)
{
if(op1.val > op2.val) return true;
else return false;
}

// Перегрузить оператор <.
public static bool operator <( dot op1, dot op2)
{
if(op1.val < op2.val) return true;
else return false;
}

Еще один пример для перегрузки операторов ==, -, *= приведен ниже. В качестве класса выберем «квадратное уравнение» с коэффициентами.

class KvadratUravn
{
     public KvadratUravn ():this(0, 0, 0)
     {
     }
     public KvadratUravn (double a_, double b_, double c_)
     {
         a=a_;
         b=b_;
         c=c_;
     }
     public double A { get { return a; } set { a = value; } }
     public double B { get { return b; } set { b = value; } }
     public double C { get { return c; } set { c = value; } }
 
 
     public static bool operator ==( KvadratUravn raz, KvadratUravn dva)
     {
         return raz.a == dva.a &&
             raz.b == dva.b &&
             raz.c == dva.c;
     }
 
     public static bool operator !=( KvadratUravn raz, KvadratUravn dva)
     {
         return raz.a != dva.a &&
             raz.b != dva.b &&
             raz.c != dva.c;
     }
 
     public static KvadratUravn operator *( KvadratUravn raz, double dva)
     {
         return new KvadratUravn (raz.a * dva,
             raz.b * dva,
             raz.c * dva);
     }
 
     public static KvadratUravn operator -( KvadratUravn raz, double dva)
     {
         return new KvadratUravn (raz.a — dva,
             raz.b — dva,
             raz.c — dva);
     }
     public override string ToString()
     {
         return string.Format(«{0}, {1}, {2}», a, b, c);
     }
     private double a;
     private double b;
     private double c;
};
 
class Program
{
     static void Main(string[] args)
     {
KvadratUravn expr = new KvadratUravn (1, 2, 3);
            Console.WriteLine(expr.ToString());
         expr *= 5;
            Console.WriteLine(expr.ToString());
         expr -= 10;
            Console.WriteLine(expr.ToString());
     }
}

В следующем фрагменте кода программы приведен пример перегрузки логических операторов !, & и | для объектов класса Dot. Если один из точек координаты не равно нулю тогда программе покажет истину, а если все координаты равны нулю, тогда программа выдает значение ложь.

// Класс для хранения координат.
class dot
{
int х, у, z; // трехмерные координаты
public dot () { х = у = z = 0; }
public static bool operator |(dot op1, dot op2)
{
if( ((op1.x != 0) || (op1.у != 0) || (op1.z != 0)) | ((op2.x != 0) || (op2.у != 0) || (op2.z != 0)) )
return true;
else
return false;
}

// Перегрузить логический оператор &.
public static bool operator &(dot op1, dot op2)
{
if( ((op1.x != 0) && (op1.у != 0) && (op1.z != 0)) & ((op2.x != 0) && (op2.y != 0) && (op2.z != 0)) )
return true;
else
return false;
}

// Перегрузить логический оператор !.
public static bool operator !(dot op)
{
if((op.x != 0) || (op.y != 0) || (op.z != 0))
return false;
else return true;
}

// Вывести координаты X, Y, Z.
public void Show()
{
Console.WriteLine(x + «, » + у + «, » + z);
}
}

Перегрузка операторов C# заключение

Важно помнить, что на перегрузку операторов есть ограничения. Нельзя использовать оператор присваивания =. Кроме них есть операторы, которые в языке С# еще не определены. Так же, нельзя изменить количество операндов. Для бинарных операторов нельзя задавать три аргумента. Поскольку в его синтаксисе указан только два аргумента.  

Чтобы создать легкий интерфейс, важно использовать перегрузки операторов. К тому же, учитывая их, вы упрощаете набранный код программы. Данное действие над операторами интересно тем, что пользователь сможет внедрить в программу свои правила и требования, контролируя функции операторов.

Также рекомендую прочитать статью Override C# | Переопределение методов C#. А также подписывайтесь на группу ВКонтакте, Telegram и YouTube-канал. Там еще больше полезного и интересного для программистов.