Kacza
Administrator
Dołączył: 29 Wrz 2010
Posty: 103
Przeczytał: 0 tematów
Pomógł: 4 razy Ostrzeżeń: 0/10 Skąd: Przemyśl/Kraków
|
Wysłany: Śro 13:20, 01 Cze 2011 Temat postu: Funkcje operatorowe |
|
|
1)Funkcje operatorowe
Funkcje operatorowe to specjalne funkcje wywoływane poprzez stosowania określonych operatorów.
Podstawowym celem stosowania funkcji operatorowych w klasach jest stworzenie mechanizmu wykonywania operacji na obiektach takich jak przy typach wbudowanych.
Kod: | class TPunkt
{
public:
int x;
int y;
void dodaj(TPunkt pp1, TPunkt pp2) {x=pp1.x+pp2.x; y=pp1.y+pp2.y;}
TPunkt operator +(TPunkt p)
{
TPunkt tmp;
tmp.x=x+p.x;
tmp.y=y+p.y;
return tmp;
}
};
void main(void)
{
TPunkt a, b, c; // tworzenie obiektów
...
...
c.dodaj(a,b); // dodaj a do b i zapisz wynik do c
c=a+b; // dodaj a do b i zapisz wynik do c
}
|
W przykładzie zastosowano wywołania dwóch funkcji, które spełniają takie samo zadanie.
Pierwsza funkcja zostaje wywołana z dwoma argumentami, które następnie są dodawane i funkcja zwraca wynik dodawania.
Kod: |
c.dodaj(a,b); // dodaj a do b i zapisz wynik do c |
Druga funkcja jest wywołana poprzez przeładowanie operatora +.
Kod: |
c=a+b; // dodaj a do b i zapisz wynik do c |
Obie funkcje wykonują to samo zadanie, ale stosowanie funkcji operatorowych jest łatwiejsze i bliższe człowiekow, ze względu na matematyczny zapis operacji. Przykładowo operator można stosować do liczb zespolonych, macierzy, czy też czysto abstrakcyjnych operacji np. zapałki + ogień To od programisty zależy jak dana operacja (operator) będzie obsłużony w funkcji operatorowej.
Następujące operatory mogą być zdefiniowane jako funkcje globalne lub metody klasy:
Kod: | + - * / % ^ & | ~ ! , < > <= >= ++ -- << >> == != && || <<new> | mogą być zdefiniowane jako metody klasy, nie jako funkcje globalne.
Operatory nie mogą być przeciążone.
2) Funkcje operatorowe
W języku C# zdefiniowano obszerny zestaw operatorów arytmetycznych, logicznych i innych. Działają one jedynie na obiektach klas predefiniowanych. Na obiektach niektórych tworzonych przez programistę klas można definiować działania. Do definiowania działań służą funkcje operatorowe np. operator*, operator=, które muszą być statyczne!!!. Niektóre operatory mogą być przeciążane, niektóre pod specjalnymi warunkami, niektóre nie mogą być przeciążane.
Deklarowanie operatora jedno , dwu argumentowego oraz operatora konwersji.
Kod: | modyfikator typ_wyniku operator przeciążony_operator ( typ nazwa ) {...}
modyfikator typ_wyniku operator przeciążony_operator ( typ nazwa , typ nazwa ) {...}
modyfikator implicit operator typ ( typ nazwa ) {...}
// konwersja niejawna.
modyfikator explicit operator typ ( typ nazwa ) {...}
// konwersja jawna. |
Reguły tworzenia operatorów :
deklaracja operatora musi zwracać public lub static.
parametry operatora musza być przekazane przez wartość. Nie mogą być przekazane przez ref lub out.
sygnatura operatora musi się różnić od innych operatorów.
wszystkie typy występujące w deklaracji operatora winny być dostępne jak sam operator.
operatory jako składowe klasy lub struktury deklarowane są w deklaracji operatora.
Przykładowy program przedstawiający wykorzystujący funkcje operatorowe.
Kod: | using System;
namespace operatory
{
struct Zesp
{
double Re,Im;
// składowe prywatne-część rzeczywista i część urojona.
Zesp ( double r , double i )
{
Re = r;
Im = i;
}
public static Zesp operator + ( Zesp a , Zesp b )
// przeciążenie operatora +.
{
Zesp c = new Zesp();
c.Re = b.Re + a.Re;
c.Im = b.Im + a.Im;
return c;
}
public static bool operator == ( Zesp a , Zesp b )
// przeciążenie operatora ==.
{
if ( a.Re == b.Re && a.Im == b.Im)
return true;
else
return false;
}
public static bool operator != ( Zesp a , Zesp b )
// przeciążenie operatora !=.
{
if ( a.Re != b.Re && a.Im != b.Im)
return true;
else
return false;
}
public static void Main ()
{
Zesp a = new Zesp (1.1 , 2.2 );
// 1 para standardowo.
Zesp b = new Zesp (4.1 , 4.4 );
Zesp aa = new Zesp (1.1 , 2.2 ); // rownosc liczb.
Zesp bb = new Zesp (1.1 , 2.2 );
Zesp aaa = new Zesp( 2.2 , 0.0 );
// roznosc liczb.
Zesp bbb = new Zesp (4.1 , 4.4 );
Zesp c = new Zesp();
c = a + b;
Console.WriteLine ( "c=a+b\na({0:f2}, {1:f2}) + b({2:f2}, {3:f2}) = c({4:f2}, {5:f2})" , a.Re , a.Im , b.Re , b.Im , c.Re ,c .Im );
c += a;
Console.WriteLine ( "c+=a\nWynik dodawania ({0:f2}, {1:f2})", c.Re , c.Im );
//sprawdzanie rownosci.
Console.WriteLine ( "\n\t\t\t\tSprawdzanie równości" ) ;
// proces sprawdzania.
Console.WriteLine ( "\n\t\t\t aa({0:f2} {1:f2}) bb({2:f2} {3:f2})" , aa.Re , aa.Im , bb.Re , bb.Im );
if ( aa == bb )
// 1 sprawdzenie.
Console.WriteLine ( "\t\t\t\t Liczby sa rowne!!!" );
else
Console.WriteLine ( "\t\t\t\t Liczby sa rózne!!!" );
//sprawdzanie nierownosci.
Console.WriteLine ("\n\t\t\t aaa({0:f2} {1:f2}) bbb({2:f2} {3:f2})" , aaa.Re , aaa.Im , bbb.Re , bbb.Im);
if ( aaa == bbb )
// 2 sprawdzenie.
Console.WriteLine ( "\t\t\t\t Liczby sa rowne!!!" );
else
Console.WriteLine ( "\t\t\t\t Liczby sa rózne!!!" );
}
}
} |
Post został pochwalony 0 razy
|
|