Урок 10. Перегрузка логического оператора C#

На десятом уроке учебника по объектно-ориентированному программированию на языке C# продолжается обсуждение перегрузки операторов. В этой статье описана перегрузка логических операторов, включая способы включения логических операторов короткого замыкания.

Логические операторы

Существует четыре логических оператора, которые могут быть напрямую перегружены для класса. Это оператор NOT (!), Оператор AND (&), оператор OR (|) и оператор XOR (^). Операторы короткого замыкания (&& и ||) не могут быть перегружены напрямую. Однако, если класс удовлетворяет определенным условиям, операторы короткого замыкания включаются автоматически .

В этой статье используется класс Vector, разработанный в предыдущих статьях. Класс Vector представляет двумерный вектор и уже перегружает арифметические операторы и операторы true и false. Если у вас нет кода, загрузите его, используя ссылку выше.

В этой статье класс Vector будет обновлен, чтобы включить перегрузку четырех логических операторов для логических операторов.

Перегрузка двоичных логических операторов

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

public static bool operator logical-operator (
    op-type operand,
    op-type2 operand2
)

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

Создание логического оператора AND (&)

Три двоичных логических оператора могут быть добавлены в класс Vector с использованием синтаксиса, описанного выше. При определении результатов каждого из них вектор будет считаться равным истине, если любая из координат отлична от нуля. Если оба свойства X и Y равны нулю, вектор будет считаться ложным.

Добавьте следующую перегрузку оператора в класс Vector для реализации функции AND:

public static bool operator &(Vector v1, Vector v2)
{
    bool v1flag = !((v1.X == 0) && (v1.Y == 0));
    bool v2flag = !((v2.X == 0) && (v2.Y == 0));
 
    return v1flag & v2flag;
}

Код оценивает координаты каждого вектора для создания логического представления в переменных 'flag'. Затем выполняется операция AND над двумя флагами и возвращается результат. Вы можете проверить код, изменив метод Main программы следующим образом и запустив консольное приложение.

static void Main(string[] args)
{
    Vector v1 = new Vector(0, 0);
    Vector v2 = new Vector(10, 0);
 
    Console.WriteLine(v1 & v1);                 // "False"
    Console.WriteLine(v1 & v2);                 // "False"
    Console.WriteLine(v2 & v1);                 // "False"
    Console.WriteLine(v2 & v2);                 //  "True"
}

Создание логических операторов OR (|) и XOR (^)

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

public static bool operator |(Vector v1, Vector v2)
{
    bool v1flag = !((v1.X == 0) && (v1.Y == 0));
    bool v2flag = !((v2.X == 0) && (v2.Y == 0));
 
    return v1flag | v2flag;
}
 
public static bool operator ^(Vector v1, Vector v2)
{
    bool v1flag = !((v1.X == 0) && (v1.Y == 0));
    bool v2flag = !((v2.X == 0) && (v2.Y == 0));
 
    return v1flag ^ v2flag;
}

Опять же, эти операторы могут быть протестированы с использованием модифицированного метода Main:

static void Main(string[] args)
{
    Vector v1 = new Vector(0, 0);
    Vector v2 = new Vector(10, 0);
 
    Console.WriteLine(v1 | v1);                 //  "False"
    Console.WriteLine(v1 | v2);                 //  "True"
    Console.WriteLine(v2 | v1);                 //  "True"
    Console.WriteLine(v2 | v2);                 //  "True"
 
    Console.WriteLine(v1 ^ v1);                 //  "False"
    Console.WriteLine(v1 ^ v2);                 //  "True"
    Console.WriteLine(v2 ^ v1);                 //  "True"
    Console.WriteLine(v2 ^ v2);                 //  "False"
}

Перегрузка унарного логического оператора

Существует только один унарный логический логический оператор. Это оператор NOT (!), Который переключает логическое значение между true и false. При перегрузке с использованием приведенного ниже унарного синтаксиса возвращаемое значение должно быть противоположным логическому представлению объекта. Как и в случае с другими унарными операторами, тип предоставляемого операнда должен совпадать с классом, в котором находится объявление.

public static bool operator !(op-type operand)

Создание логического оператора NOT (!)

Оператор NOT для класса Vector будет проверять содержимое свойств X и Y. Как описано выше, если обе координаты равны нулю, логическое значение для объекта является false. Однако, поскольку это оператор NOT, мы выполним проверку и вернем true только тогда, когда оба значения равны нулю. Добавьте следующий код в класс для предоставления оператора NOT:

public static bool operator !(Vector v)
{
    return ((v.X == 0) && (v.Y == 0));
}

Чтобы проверить, что оператор работает правильно, измените метод Main следующим образом:

static void Main(string[] args)
{
    Vector v1 = new Vector(0, 0);
    Vector v2 = new Vector(10, 0);
 
    Console.WriteLine(!v1);                     //  "True"
    Console.WriteLine(!v2);                     // "False"
}

Включение операторов короткого замыкания

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

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

• Класс должен перегружать нормальные логические операторы (& и |) операцией, возвращающей значение того же типа, что и содержащий класс. Каждый параметр оператора также должен иметь тип содержащего класса.
• True и False операторы должны быть перегружены.

Когда оператор вызывается, операторы true или false используются для определения статуса первого операнда. Если это гарантирует результат операции, результат возвращается немедленно. Когда состояние первого операнда не вызывает результат, оператор AND или OR используется для двух значений, чтобы определить результат.

Добавление предварительных реквизитов оператора короткого замыкания в векторный класс

Класс Vector уже содержит перегруженные операторы true и false. Чтобы включить операторы короткого замыкания, нам просто нужно добавить правильную подпись для операторов AND и OR. Поскольку они должны возвращать результат Vector, который может быть оценен как true или false в соответствии с результатами, он вернет (0,0), если операция равна false, и (1,1) для true.

Измените код для существующих & и | операторов перегружается следующим образом:

public static Vector operator &(Vector v1, Vector v2)
{
    bool v1flag = !((v1.X == 0) && (v1.Y == 0));
    bool v2flag = !((v2.X == 0) && (v2.Y == 0));
 
    if (v1flag & v2flag)
        return new Vector(1, 1);
    else
        return new Vector(0, 0);
}
 
public static Vector operator |(Vector v1, Vector v2)
{
    bool v1flag = !((v1.X == 0) && (v1.Y == 0));
    bool v2flag = !((v2.X == 0) && (v2.Y == 0));
 
    if (v1flag | v2flag)
        return new Vector(1, 1);
    else
        return new Vector(0, 0);
}

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

static void Main(string[] args)
{
    Vector v1 = new Vector(0, 0);
    Vector v2 = new Vector(10, 0);
 
    if (v1 && v2)
        Console.WriteLine("v1 && v2 = true");
    else
        Console.WriteLine("v1 && v2 = false");  //  "v1 && v2 = false"
     
    if (v1 || v2)
        Console.WriteLine("v1 || v2 = true");   //  "v1 || v2 = true"
    else
        Console.WriteLine("v1 || v2 = false");
}