Перегрузка

Предыдущая страница

Следующая страница  

D позволяет указать более одного определения для имени функции или оператора в одной и той же области видимости, это называется перегрузкой функции и перегрузкой оператора соответственно.

Перегруженное объявление – это объявление, которое было объявлено с тем же именем, что и предыдущее объявление в той же области видимости, за исключением того, что оба объявления имеют разные аргументы и, очевидно, различные определения (реализацию).

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

Перегрузка функций

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

Пример

В следующем примере используется одна и та же функция print() для отображения разных типов данных:

import std.stdio; 
import std.string; 

class printData { 
   public: 
      void print(int i) { 
         writeln("Вывод int: ",i); 
      }

      void print(double f) { 
         writeln("Вывод float: ",f );
      }

      void print(string s) { 
         writeln("Вывод string: ",s); 
      } 
}; 
 
void main() { 
   printData pd = new printData();  
   
   // Вызов print для вывода целого числа
   pd.print(5);
   
   // Вызов print для вывода числа с плавающей точкой 
   pd.print(500.263); 
   
   // Вызов print для вывода строки 
   pd.print("Привет, D"); 
} 

Когда вы скомпилируете и выполните эту программу, она возвратит следующий результат:

Вывод int: 5
Вывод float: 500.263
Вывод string: Привет, D

Перегрузка операторов

Вы можете переопределить или перегрузить большинство встроенных операторов, доступных в D. Таким образом, программист может использовать операторы с определёнными пользователем типами также, как со встроенными типами.

Операторы могут быть перегружены с помощью функции с именем, состоящим из строки op, за которой следуют Add, Sub и т.д., исходя из того, какой оператор должен быть перегружен. Мы можем перегрузить оператор +, чтобы складывать две коробки, как показано ниже.

Box opAdd(Box b) { 
   Box box = new Box(); 
   box.length = this.length + b.length; 
   box.breadth = this.breadth + b.breadth; 
   box.height = this.height + b.height; 
   return box; 
}

Замечание.
Такие функции для перегрузки операторов, как opAdd, opSub и т.д. являются механизмом из первой версии языка D. В D2 в настоящее время они допустимы, но не рекомендуются для использования, т.к. их поддержка не гарантируется в будущем. Вместо них нужно использовать унифицированные шаблонные функции opUnary, opBinary, opCmp и т.д. (см. подраздел Типы перегрузки операторов) – прим. пер.

В следующем примере показана концепция перегрузки оператора с использованием функции-члена. Здесь объект передается в виде аргумента, его свойства доступны через этот объект. Объект, в котором вызван оператор, можно получить с помощью оператора this, как показано ниже:

import std.stdio;

class Box { 
   public:  
      double getVolume() { 
         return length * breadth * height; 
      }

      void setLength( double len ) { 
         length = len; 
      } 

      void setBreadth( double bre ) { 
         breadth = bre; 
      }

      void setHeight( double hei ) { 
         height = hei; 
      }

      Box opAdd(Box b) { 
         Box box = new Box(); 
         box.length = this.length + b.length; 
         box.breadth = this.breadth + b.breadth; 
         box.height = this.height + b.height; 
         return box; 
      } 

   private: 
      double length;      // Длина коробки 
      double breadth;     // Ширина коробки 
      double height;      // Высота коробки 
}; 

// Основная функция программы 
void main( ) { 
   Box box1 = new Box();    // Объявление коробки box1 типа Box 
   Box box2 = new Box();    // Объявление коробки box2 типа Box 
   Box box3 = new Box();    // Объявление коробки box3 типа Box 
   double volume = 0.0;     // Здесь хранится объём коробки . 
   
   // спецификация коробки 1 
   box1.setLength(6.0); 
   box1.setBreadth(7.0); 
   box1.setHeight(5.0);
   
   //спецификация коробки 2 
   box2.setLength(12.0); 
   box2.setBreadth(13.0); 
   box2.setHeight(10.0); 
   
   // объём коробки 1 
   volume = box1.getVolume(); 
   writeln("Объём коробки 1 : ", volume);
   
   // объём коробки 2 
   volume = box2.getVolume(); 
   writeln("Объём коробки 2 : ", volume); 
   
   // Сложить два объекта следующим образом: 
   box3 = box1 + box2; 
   
   // объём коробки 3 
   volume = box3.getVolume(); 
   writeln("Объём коробки 3 : ", volume);  
} 

Когда вы скомпилируете и выполните эту программу, она возвратит следующий результат:

Объём коробки 1 : 210
Объём коробки 2 : 1560
Объём коробки 3 : 5400

Типы перегрузки операторов

В основном, существует три типа перегрузки операторов, как указано ниже.

Существует гораздо больше методов, ответственных за перегрузку операторов, попробую их перечислить:

• opCast – перегрузка оператора приведения типов cast
• opEquals – перегрузка оператора проверки на равенство == (и, косвенно, проверки на неравенство !=)
• opCall – создание оператора вызова функции, т.е. при наличии метода с таким именем у объекта a, этот объект можно вызывать как функцию a()
• opAssign, opIndexAssign – перегрузка операторов присваивания = и присваивания по индексу a[i]=
• opOpAssign, opIndexOpAssign – перегрузка бинарных операций "на месте", или, другими словами, операций, совмещённых с присваиванием, например +=, -= и т.д., и, соответственно, таких же операций по индексу
• opIndex, opSlice, opDollar – перегрузка операторов, связанных с массивами, соответственно, индексации [i], выделения среза [i..j] и размера массива $
• opDispatch – создание оператора перенаравления (диспетчера), в который будут перенаправляться все вызовы несуществующих у объекта методов

Предыдущая страница

Следующая страница