Přetížení operátoru

Článek
03/05/2024

Toto téma popisuje, jak přetěžovat aritmetické operátory ve třídě nebo v typu záznamu a na globální úrovni.

Syntaxe

// Overloading an operator as a class or record member.
static member (operator-symbols) (parameter-list) =
    method-body
// Overloading an operator at the global level
let [inline] (operator-symbols) parameter-list = function-body

Poznámky

V předchozí syntaxi je symbol operátoru jedním z +, -, *, /, , =atd. Seznam parametrů určuje operandy v pořadí, v jakém se zobrazují v obvyklé syntaxi daného operátoru. Tělo metody vytvoří výslednou hodnotu.

Přetížení operátoru musí být statické. Přetížení operátoru pro unární operátory, například + a -, musí v symbolu operátoru použít vlnovku (~) k označení, že operátor je unární operátor a nikoli binární operátor, jak je znázorněno v následující deklaraci.

static member (~-) (v : Vector)

Následující kód ukazuje třídu Vector, která má pouze dva operátory, jeden pro unární mínus a jeden pro násobení pomocí skaláru. V tomto příkladu jsou pro skalární násobení potřeba dvě přetížení, protože operátor musí fungovat bez ohledu na pořadí vektoru a skaláru.

type Vector(x: float, y : float) =
   member this.x = x
   member this.y = y
   static member (~-) (v : Vector) =
     Vector(-1.0 * v.x, -1.0 * v.y)
   static member (*) (v : Vector, a) =
     Vector(a * v.x, a * v.y)
   static member (*) (a, v: Vector) =
     Vector(a * v.x, a * v.y)
   override this.ToString() =
     this.x.ToString() + " " + this.y.ToString()

let v1 = Vector(1.0, 2.0)

let v2 = v1 * 2.0
let v3 = 2.0 * v1

let v4 = - v2

printfn "%s" (v1.ToString())
printfn "%s" (v2.ToString())
printfn "%s" (v3.ToString())
printfn "%s" (v4.ToString())

Vytvoření nových operátorů

Přetížit lze všechny standardní operátory, avšak můžete také vytvořit nové operátory mimo sekvence určitých znaků. Povolené znaky operátoru jsou , , , *-+&.<=@>?%/, ^, a .~|$! Znak ~ má zvláštní význam, který vytváří z operátoru unární operátor a není součástí sekvence znaků operátoru. Ne všechny operátory mohou být unární.

V závislosti na přesné posloupnosti znaků bude mít operátor určitou přednost a asociativitu. Asociativita může být buď zleva doprava, nebo zprava doleva a používá se při zobrazení sekvence operátorů stejné úrovně priority bez použití závorek.

Znak operátoru . neovlivňuje prioritu, takže pokud je například třeba definovat vlastní verzi násobení, která má stejnou prioritu a asociativitu operátorů jako obyčejné násobení, je možné vytvořit operátory, jako například .*.

Operátor $ musí být samostatný a bez dalších symbolů.

Tabulku, která zobrazuje prioritu všech operátorů v jazyce F#, najdete v odkazu na symboly a operátory.

Názvy přetíženého operátoru

Když kompilátor jazyka F# kompiluje výraz operátoru, generuje metodu, která má pro tento operátor název vygenerovaný kompilátorem. Toto je název, který se zobrazí v běžném zprostředkujícím jazyce (CIL) pro metodu, a také v reflexi a IntelliSense. V kódu jazyka F# obvykle není nutné tyto názvy používat.

Následující tabulka uvádí standardní operátory a jejich odpovídající vygenerované názvy.

Operátor	Vygenerovaný název
`[]`	`op_Nil`
`::`	`op_Cons`
`+`	`op_Addition`
`-`	`op_Subtraction`
`*`	`op_Multiply`
`/`	`op_Division`
`@`	`op_Append`
`^`	`op_Concatenate`
`%`	`op_Modulus`
`&&&`	`op_BitwiseAnd`
`\|\|\|`	`op_BitwiseOr`
`^^^`	`op_ExclusiveOr`
`<<<`	`op_LeftShift`
`~~~`	`op_LogicalNot`
`>>>`	`op_RightShift`
`~+`	`op_UnaryPlus`
`~-`	`op_UnaryNegation`
`=`	`op_Equality`
`<=`	`op_LessThanOrEqual`
`>=`	`op_GreaterThanOrEqual`
`<`	`op_LessThan`
`>`	`op_GreaterThan`
`?`	`op_Dynamic`
`?<-`	`op_DynamicAssignment`
`\|>`	`op_PipeRight`
`<\|`	`op_PipeLeft`
`!`	`op_Dereference`
`>>`	`op_ComposeRight`
`<<`	`op_ComposeLeft`
`<@ @>`	`op_Quotation`
`<@@ @@>`	`op_QuotationUntyped`
`+=`	`op_AdditionAssignment`
`-=`	`op_SubtractionAssignment`
`*=`	`op_MultiplyAssignment`
`/=`	`op_DivisionAssignment`
`..`	`op_Range`
`.. ..`	`op_RangeStep`

Všimněte si, že not operátor v jazyce F# negeneruje op_Inequality , protože se nejedná o symbolický operátor. Jedná se o funkci, která generuje il, která neguje logický výraz.

Další kombinace znaků operátoru, které zde nejsou uvedeny, lze použít jako operátory a mohou mít názvy, jež jsou vytvořeny zřetězením názvů jednotlivých znaků z následující tabulky. Například +! se stane op_PlusBang.

Znak operátoru	Název
`>`	`Greater`
`<`	`Less`
`+`	`Plus`
`-`	`Minus`
`*`	`Multiply`
`/`	`Divide`
`=`	`Equals`
`~`	`Twiddle`
`$`	`Dollar`
`%`	`Percent`
`.`	`Dot`
`&`	`Amp`
`\|`	`Bar`
`@`	`At`
`^`	`Hat`
`!`	`Bang`
`?`	`Qmark`
`(`	`LParen`
`,`	`Comma`
`)`	`RParen`
`[`	`LBrack`
`]`	`RBrack`

Operátory Prefix a Infix

Před operandy nebo operandy se očekávají operátory předponami , podobně jako u funkce. Očekává se, že operátory infixu budou umístěny mezi dvěma operandy.

Pouze některé operátory lze používat jako operátory Prefix. Některé operátory jsou vždy operátory Prefix, ostatní mohou být Prefix nebo Infix a zbývající jsou vždy operátory Infix. Operátory, které začínají znakem !, s výjimkou != a operátoru ~ nebo opakované sekvence~, jsou vždy operátory Prefix. Operátory +, -, +., -., &, &&, % a %% mohou být operátory Prefix nebo Infix. Rozlišovat mezi Prefix a Infix verzí operátoru lze přidáním znaku ~ na začátek operátoru Prefix, a to při jeho definici. Znak ~ se nebude používat při použití operátoru, ale pouze při jeho definici.

Příklad

Následující kód ukazuje použití přetěžování pro implementaci typu zlomku. Zlomek je reprezentován čitatelem a jmenovatelem. Funkce hcf se používá k určení nejvyššího společného faktoru, který slouží k redukci zlomků.

// Determine the highest common factor between
// two positive integers, a helper for reducing
// fractions.
let rec hcf a b =
  if a = 0u then b
  elif a<b then hcf a (b - a)
  else hcf (a - b) b

// type Fraction: represents a positive fraction
// (positive rational number).
type Fraction =
   {
      // n: Numerator of fraction.
      n : uint32
      // d: Denominator of fraction.
      d : uint32
   }

   // Produce a string representation. If the
   // denominator is "1", do not display it.
   override this.ToString() =
      if (this.d = 1u)
        then this.n.ToString()
        else this.n.ToString() + "/" + this.d.ToString()

   // Add two fractions.
   static member (+) (f1 : Fraction, f2 : Fraction) =
      let nTemp = f1.n * f2.d + f2.n * f1.d
      let dTemp = f1.d * f2.d
      let hcfTemp = hcf nTemp dTemp
      { n = nTemp / hcfTemp; d = dTemp / hcfTemp }

   // Adds a fraction and a positive integer.
   static member (+) (f1: Fraction, i : uint32) =
      let nTemp = f1.n + i * f1.d
      let dTemp = f1.d
      let hcfTemp = hcf nTemp dTemp
      { n = nTemp / hcfTemp; d = dTemp / hcfTemp }

   // Adds a positive integer and a fraction.
   static member (+) (i : uint32, f2: Fraction) =
      let nTemp = f2.n + i * f2.d
      let dTemp = f2.d
      let hcfTemp = hcf nTemp dTemp
      { n = nTemp / hcfTemp; d = dTemp / hcfTemp }

   // Subtract one fraction from another.
   static member (-) (f1 : Fraction, f2 : Fraction) =
      if (f2.n * f1.d > f1.n * f2.d)
        then failwith "This operation results in a negative number, which is not supported."
      let nTemp = f1.n * f2.d - f2.n * f1.d
      let dTemp = f1.d * f2.d
      let hcfTemp = hcf nTemp dTemp
      { n = nTemp / hcfTemp; d = dTemp / hcfTemp }

   // Multiply two fractions.
   static member (*) (f1 : Fraction, f2 : Fraction) =
      let nTemp = f1.n * f2.n
      let dTemp = f1.d * f2.d
      let hcfTemp = hcf nTemp dTemp
      { n = nTemp / hcfTemp; d = dTemp / hcfTemp }

   // Divide two fractions.
   static member (/) (f1 : Fraction, f2 : Fraction) =
      let nTemp = f1.n * f2.d
      let dTemp = f2.n * f1.d
      let hcfTemp = hcf nTemp dTemp
      { n = nTemp / hcfTemp; d = dTemp / hcfTemp }

   // A full set of operators can be quite lengthy. For example,
   // consider operators that support other integral data types,
   // with fractions, on the left side and the right side for each.
   // Also consider implementing unary operators.

let fraction1 = { n = 3u; d = 4u }
let fraction2 = { n = 1u; d = 2u }
let result1 = fraction1 + fraction2
let result2 = fraction1 - fraction2
let result3 = fraction1 * fraction2
let result4 = fraction1 / fraction2
let result5 = fraction1 + 1u
printfn "%s + %s = %s" (fraction1.ToString()) (fraction2.ToString()) (result1.ToString())
printfn "%s - %s = %s" (fraction1.ToString()) (fraction2.ToString()) (result2.ToString())
printfn "%s * %s = %s" (fraction1.ToString()) (fraction2.ToString()) (result3.ToString())
printfn "%s / %s = %s" (fraction1.ToString()) (fraction2.ToString()) (result4.ToString())
printfn "%s + 1 = %s" (fraction1.ToString()) (result5.ToString())

Výstup:

3/4 + 1/2 = 5/4
3/4 - 1/2 = 1/4
3/4 * 1/2 = 3/8
3/4 / 1/2 = 3/2
3/4 + 1 = 7/4

Operátory na globální úrovni

Je také možné definovat operátory na globální úrovni. Následující kód definuje operátor +?.

let inline (+?) (x: int) (y: int) = x + 2*y
printf "%d" (10 +? 1)

Výstupem kódu uvedeného výše je 12.

Vzhledem k tomu, že pravidla oboru jazyka F# nařizují, že nově definované operátory mají přednost před vestavěnými operátory, je možné tímto způsobem předefinovat běžné aritmetické operátory.

U globálních operátorů, které mnohdy představují malé funkce, jež jsou nejlépe začlenitelné do volaného kódu, se často používá klíčové slovo inline. Vložení funkcí operátoru umožňuje operátorům pracovat se staticky řešenými typy parametrů za účelem vytvoření staticky řešeného generického kódu. Další informace najdete v tématu Vložené funkce a staticky vyřešené parametry typu.

Viz také

Členové

Sdílet prostřednictvím