Operatori

Operatorul este un membru care definește semnificația unei expresii operator care poate fi aplicată unei instanțe a unei clase. Pentru cei care cunosc C++, operatorul corespunde supraîncărcării din respectivul limbaj. Sintaxa:

[atribut] modificatorOperator declaratieDeOprator corpOperator

1. Operatorii trebuie declarați publici sau statici.
2. Parametrii operatorilor trebuie să fie de tip valoare. Nu se admit parametri de tip ref sau out.
3. În antetul unui operator nu poate apărea, de mai multe ori, același modificator.

Se poate declara operatori: unari, binari și de conversie.

Operatori unari

Supraîncărcarea operatorilor unari are următoarea sintaxă:

tip operatorUnarSupraîncărcabil (tip identificator) corp

Operatorii unari supraîncărcabili sunt: + – ! ˜ ++ – true false.

Reguli pentru supraîncărcarea operatorilor unari:

Fie T clasa care conține definiția operatorului

1. Un operator + – ! ˜ poate returna orice tip și preia un singur parametru de tip T
2. Un operator ++ sau — trebuie să returneze un rezultat de tip T și preia un singur parametru de tip T
3. Un operator unar true sau false returnează bool și trebuie să preia un singur parametru de tip T. Operatorii true și false trebuie să fie ambii definiți pentru a preveni o eroare de compilare.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Exemplu
{
    class Complex
    {
        private int x;
        private int y;
        public Complex()
        {
        }
        public Complex(int i, int j)
        {
            x = i;
            y = j;
        }
        public void Afis()
        {
            Console.WriteLine("{0} {1}i", x, y);
        }
        public static Complex operator -(Complex c)
        {
            Complex temp = new Complex();
            temp.x = -c.x;
            temp.y = -c.y;
            return temp;
        }
    }
    class Program
    {
	    public static void Main()
	    {
		    Complex c1 = new Complex(10, 13);
		    c1.Afis();
		    Complex c2 = new Complex();
		    c2.Afis();
		    c2 = -c1;
		    c2.Afis();
		    Console.ReadLine();
	    }
    }
}

 Operatori binari

Supraîncărcarea operatorilor binari are următoarea sintaxă:

tip operator operatorBinarSupraîncărcabil (tip identificator,
tip identificator) corp

Operatorii binari supraîncărcabili sunt: + – * / % & | ^ << >> == != > < >= <=

Reguli pentru supraîncărcarea operatorilor binari:

1. Cel puțin unul din cei doi parametri trebuie să fie de tipul clasei în care respectivul operator a fost declarat.
2. Operatorii de shift-are trebuie să aibă primul parametru de tipul clasei în care se declară, iar al doilea parametru de tip int
3. Un operator binar poate returna orice tip.
4. Următorii operatorii trebuie să se declare în pereche:

• operatorii == și !=
• operatorii > și <
• operatorii >= și <=

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ExempluOperatori
{
    class Complex
    {
        private int x;
        private int y;
        public Complex()
        {
        }
        public Complex(int i, int j)
        {
            x = i;
            y = j;
        }
        public void Afis()
        {
            Console.WriteLine("{0} {1}", x, y);
        }
        public static Complex operator +(Complex c1, Complex c2)
        {
            Complex temp = new Complex();
            temp.x = c1.x + c2.x;
            temp.y = c1.y + c2.y;
            return temp;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Complex c1 = new Complex(1, 2);
            Console.Write("c1: ");
            c1.Afis();
            Complex c2 = new Complex(3, 4);
            Console.Write("c2: ");
            c2.Afis();
            Complex c3 = new Complex();
            c3 = c1 + c2;
            Console.WriteLine("\nc3 = c1 + c2\n");
            Console.Write("c3: ");
            c3.Afis();
            Console.ReadLine();
        }
    }
}

 Operatori de conversie

Operatorul de conversie introduce o conversie definit[ de utilizator. Această conversie nu va suprascrie conversiile predefinite. Operatorii de conversie pot fi:

• impliciți – se efectuează de la un tip ”mai mic” la un tip ”mai mare” și reușesc întotdeauna, nepierzându-se date
• expliciți – se efectuează prin intermediul expresiilor de conversie, putându-se pierde date.

Sintaxa:

implicit operator tip(tip parametru) corp
explicit operator tip(tip parametru) corp

Un operator de acest tip va face conversia de la tipul sursa (S) (tipul parametrului din antet) în tipul destinație (D) tipul returnat).

O clasă poate să declare un operator de conversie de la un tip S la un tip D dacă:

1. S și D au tipuri diferite
2. S sau D este clasa în care se face definirea
3. S și D nu sunt object sau tip interfață
4. S și D nu sunt baze una pentru cealaltă

Conversii dintr-un tip de bază într-o clasă și un tip clasă într-un tip de bază folosind conversia operator:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Exemplu
{
    class MyDigit
    {
        private int x;
        public MyDigit()
        {
        }
        public MyDigit(int i)
        {
            x = i;
        }
        public void ShowDigit()
        {
            Console.WriteLine("{0}", x);
        }
        public static implicit operator int(MyDigit md)
        {
            return md.x;
        }
        public static explicit operator MyDigit(int val)
        {
            return new MyDigit(val);
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            MyDigit md1 = new MyDigit(10);
            int x = md1; //Implicit
            Console.WriteLine(x);
            int y = 25;
            MyDigit md2 = (MyDigit)y; //Explicit
            md2.ShowDigit();
            Console.ReadLine();
        }
    }
}

Conversia dintr-un tip clasă în altul folosind conversia operator:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace OperatoriImplicitiExpliciti
{
    class Clasa1
    {
        public int x;
        public Clasa1(int a)
        {
            x = a;
        }
        public void Afis1()
        {
            Console.WriteLine(x);
        }
        public static explicit operator Clasa2(Clasa1 mc1)
        {
            Clasa2 mc2 = new Clasa2(mc1.x * 10, mc1.x * 20);
            return mc2;
        }
    }
    class Clasa2
    {
        public float x, y;
        public Clasa2(float a, float b)
        {
            x = a;
            y = b;
        }
        public void Afis2()
        {
            Console.WriteLine(x);
            Console.WriteLine(y);
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            Clasa1 mc1 = new Clasa1(100);
            mc1.Afis1();
            Clasa2 mc2 = (Clasa2)mc1;
            mc2.Afis2();
            Console.ReadLine();
        }
    }
}