1 – dars. C++ Dasturlash tilining kelib chiqishi xaqida ma’lumot

74 - DARS. SINFLAR DO’STLARI.AMALLARNI KAYTA YUKLASH STANDART AMALLARINI QAYTA YUKLASH.
S ++ tilining ajoyib hususiyatlaridan biri standart amallarni yangi ma'lumotlar turlariga kullash imkoniyatidir. Masalan satrlani ulashni S1=S2 kurinishda belgilash ancha ulaydir. Bu amalni simvolli massivlarga yoki satrli konstantalarga qo’llashning iloji yo’q. Lekin S1 va S2 ni biror sinf ob'ektlari sifatida (masalan Stroka sinf) tavsiflansab ular uchun amalini kiritish mumkin bo’ladi. Amalni ma'lumotlarning yangi tipiga qo’llash uchun dasturchi “ operatsiya – funktsiya “ deb ataluvchi mahsus funktsiyani kiritishi lozim. Operatsiya – funktsiya ta'rifi qo’yidagicha.

Qaytariluvchi_ma'lumot_tini operator operatsiya_belgisi

( operatsiya-funktsiya-parametrlari-spetsifikatsiyasi )

{ operatsiya-funktsiya-tanasi-operatorlari }

Kerak bo’lganda bu funktsiya operator prototipini kiritish mumkin.

Qaytariluvchi-ma'lumot-tipi+operator operatsiya-belgisi

{ operatsiya-funktsiya-parametrlari-spetsifikatsiyasi )

Misol uchun * amalni biror T sinfga tegishli ob'ektlarga qo’llash uchun qo’yidagicha funktsiya e'lon qilishi mumkin:

T operator * ( Tx,Ty )

Bu usulda ta'riflangan operatsiya qo’shimcha yuklangan (inglizchasiga-overload) deb ataladi. Agar T sinf uchun yuqorida keltirilgan turdagi funktsiya e'lon qilingan bo’lsa, A*V ifoda operator (A,V) sifatida qaraladi. Sinf ob'ektlariga funktsiya-operatorni qo’llash uchun operatsiya-funktsiya yoki sinf kompanenta funktsiyasi yoki do’stona funktsiya bo’lishi, eki parametrlardan birortasi sinf tipiga ega bo’lishi kerak. Qo’yidagi misolda amalini satrlarga qo’llash usuli kursatilgan. Buning uchun len – satr uzunligi , ch-simvolli massivga ko’rsatkich parametrlardan iborat. Streko sinfidan foydalanamiz. Bu sinfda ikki konstruktor mavjuddir. Birinchisi yaratilaetgan ob'ekt uchun hotiradan satr sifatida joy ajratadi. Ikkinchisi haqiqiy parametr asosida ob'ekt yaratadi. Sinfdan tashkarida operatsiya-funktsiyani qo’yidagicha S bilan aniqlaymiz:

Strka & operator + (stroka & A, stroka & B),

Bu operatsiya-funktsiya ‘+’ amalini stroka sinfiga tegishli ob'ektlarga qo’llash uchun ishlatiladi. Funktsiya operatsiya tanasi asosiy dasturdan keyin keltirilgan, shuning uchun asosiy dasturda bu funktsiyaning prototipi joylashtirilgan.

# include “ stroka. Spp “

stroka & operator + (stroka & A, stroka & B);

void main (void)

{ stroka X (“qui”);

stroka Y (“vivra”);

stroka J (“verra”);

stroka C;

c=x+Y+J+”-Tirik bulsak, ko’ramiz”.;

c. di 1 play ( );

}

stroka 2 operator + (stroka &, stroka & b)

{ int ii=a. len-str ( ) + b.len-str ( );

stroka * ps;

ps=new stroka (ii);

strcpy (ps-string ( ), a.string ( ) );

strcut (ps-string ( ),b.string ( ) );

ps-len_str ( )=ii;

return * ps;

}

Dastur bajarilishi natijasi:

Satr uzunligi 36

Satr mazmuni: Qui Vivra Verra –Tirik bo’lsak quramiz!

Dasturda satrlar uchun kiritilgan ‘+’ amali bitta ifodada uch marta qo’llanadi:

X+Y+J f”-Tirik bo’lsak qo’ramiz!”

Bunday qisqa murojatdan tashqari to’la operatsiya funktsiyani chiqarish mumkin:

C= operator t ( X,Y );

C= operator t ( C,J );

C= operator t ( C,” Tirik bo’lsak, quramiz!” )

Ikkinchi imkoniyat sinf kompanenta funktsiyalardan foydalanishdir. Har qanday biror amal sinfga tegishli statik kompanenta operatsiya-funktsiya yordamida qayta yuklanishi mumkin. Bu holda bitta parametrga ega bo’lib, sarlavhasi qo’yidagi ko’rinishda bo’ladi:

T operator & (T.X)

Bu erda T-sinf, &-operatsiya.

Bu holda A&V ifoda A. Operator & (B) murojaat sifatida talqin yotiladi. Kerak bo’lganda this ko’rsatkichi orqali murojat qilish mumkin. Misol tariqasida ‘t’ amalini point sinfi bilan ta'riflanuvchi displeydagi nuqtalarga qullaymiz. Soddalashtirish uchun point sinfida eng kerakli kompanentalarni qoldiramiz.

# include < graphic1. h >

cla11 point1

protected:

int x,y;

public:

point1 (int xi=0, int yi=0)

{ x=xi; y=yi; }

void show (void) { putpinel (x,y,get color ( ) );};

point1 operator+ (point2 p);

};

point1 point1 : : operator + (point &p)

{ point1: d;

d.x=thi1-x+p.x;

d.y=thi1-y+p.y;

Return d;

}

# include

ooid main ( )

{

int dr=DETECT, mod;

point1 A(200,50);

point1 B;

point1 D(50,120);

INITYRAPH (& DR, & MOD, “C\\borlandc \\ BG$”);

A. show ( );

getch ( );

B. show ( ); getch ( );

D show ( ); getch ( );

B=A+P;

B. show ( ); getch ( );

B=A. operator t (B);

B. show ( ); getch ( );

closegraph ( );

}

Dastur bajarilishi natijasida display ekraniga ketma-ket qo’yidagi nuqtalar qo’yiladi: A(200,50); B(0,0); D(50,120); B(250,70), B(450,220)

Operatsiya funktsiyani oddiy sinf komponenta funktsiyasi sifatida chaqirish mumkin:

Point1 * ptr=& A;

B=ptr – operator + (D);

Biz sinf amalini global operatsiya-funktsiya va kompanenta operatsiya-funktsiya yordamida qayta yuklashni ko’rib chiqdik. Endi unar amalni sinf do’stona funktsiyasi yordamida qayta yuklashni ko’rib chiqamiz. “N ulchovli fazo radius-vektori “ sinfini kiritamiz va bu sinf uchun ‘-‘-unar operatsiya funktsiyani kiritamiz. Bu operatsiya vektor yunalishini teskarisiga o’zgartiradi.

# include < iostream. h >

class vector

int N;

double * x;

friend vector 2 operator – (vector &);

public:

vector (int n, double * xn)

{ N=n; x=xn; }

void di 1 play ( );

};

void vector : : di 1 play ( )

{ cont < < “\n Vektor koordinatalari :”;

for ( int I=0; I

cont < < “\t” < < x [I];

}

vector 2 operator –(vector & 0)

{ for ( int I=0; I

V. x[I]=-V. x[I];

Retun v;

}

Qo’yidagi kompanentalarni qayta yuklash mumkin emas.

strukturalangan ob'ekt kompanentasini to’g’ridan to’g’ri tanlash.

#komponentaga ko’rsatkich orqali murojaat qilish;

:shartli operatsiya:

:: ko’rinish doirasini aniqlash;

Sizeof-hotira hajmini aniqlash ;

# preprotsessor direktivasi;

## protsessorli amal;

Qayta yuklash mehanizmi yana quyidagi hususiyatlarga ega:

Standart amallarni qo’shimcha yuklanganda prioritetlarini o’zgartirish mumkin emas.

Qo’shimcha yuklangan amallar uchun ifodalar sintaksisini o’zgartirish mumkin emas. Unar yoki binar amallarni kiritish mumkin emas.

Amallar uchun simvollar kiritish mumkin emas masalan kupaytirish uchun **belgisi.

Har qanday binar amal ikki usul bilan aniqlanadi, yoki bir parametrli kompanenta funktsiya sifatida yoki global yoki do’stona global ikki parametrli funktsiya. Birinchi holda x*y ifoda h. Operator*(y) murojaatni ikkinchi holda esa Operator*(x*y) murojaatni bildiradi.

Binar '=', '[ ]', '->' amallar semantikasiga ko’ra Operator=, Operator[ ], Operator-> global funktsiya bo’lolmaydi. Balkim nostatik kompanenta funktsiyasi bo’lishi lozim.

Har qanday amal '$' sinf ob'ektlari uchun ikki usulda aniqlanadi yoki parametrsiz komponenta funktsiya yoki bir parametrli (balkim do’stona) global funktsiya. Prefiks amal uchun xz ifoda , postfiks amal uchun Z ifoda komponenta funktsiya z.operator*( ) yoki global funktsiya operator*(z) chaqirilishini bildiradi. C++ tilida ba'zi amallarni boshqa amallarning kombinatsiyasi sifatida aniqlanadi.

Misol uchun j+m butun son uchun m+=1ni bu amal bo’lsa m=m+1 ni bildiradi. Bunday avtomatik almashtirishlar qo’shimcha yuklangan amallar uchun bajarilmaydi. Misol uchun umumiy holda operator*=() ta'rifni operator*( ) ta'rif va operator=( ) ta'rifdan keltirib chiqarib bo’lmaydi.

Agar ifodada foydalanuvchi kiritgan sinf ob'ekti qatnashmasa uning ma'nosini o’zgartirib bo’lmaydi. Misol uchun faqat ko’rsatkichlarga ta'sir qiluvchi amallarni kiritish mumkin emas.

Agar operatsiya funktsiyaning birinchi parametri standart tip bo’lishi kerak bo’lsa, bunday operatsiya-funktsiya kompanenta-funktsiya bulolmaydi. Misol uchun aa- biror sinf ob'ekti bo’lsin va uning uchun '+' amali qo’llangan bo’lsin. AA+2 ifoda uchun yoki AA.operator(2) yoki operator+(AA,2) ifoda chaqirilishi mumkin. 2++AA ifoda uchun operator+(AA,2) chaqirilishi mumkin lekin z. operator+(AA) hatoga olib keladi. Amallar kengaytirilganda ular uchun har hil tiplar qolib inatsiyasini oldindan nazarda tutish lozim. Lekin operatsiya-funktsiyalarga murojaat qilinganda standart tiplar almashinuvchi qoidalari ishlatiladi, shuning uchun tiplarning hamma kombinatsiyalarini hisobga olish zarurati yuq. Kupgina hollarda binar amallar uchun qo’yidagi hollarni hisobga olish etarlidir.

# standart tip, cinf

# sinf, standart tip

# sinf, sinf

Masalan: Somplex sinfi uchun qo’yidagi do’stona operatsiya-funktsiyalarni kiritish mumkin:

Complex operator++ (Somplex, Somplex y)

{Return (Somplex(x.real+y.real, x.imag+y.imag());

Complex operator+(Complex x, double y}

{Return (Complex (x.real+y, x.imag ())}

Shundan sung qo’yidagi ifodalarni qo’llash mumkin bo’ladi:

Complex CC (1.0, 2.0);

Complex EE;

EE=4.0+CC;

EE=EE+2.0;

EE=CC+EE;

CC=EE+'e';

Standart tiplarni sinf ob'ektiga keltirish vazifasini konstruktorga topshirish mumkin. Masalan Complex sinfiga qo’yidagi konstruktorni qo’yish hamma yordamchi funktsiyalardan halos bo’lish imkonini beradi:

Complex (double x);

{Real=x; imag=0.0;);

Bu holda qo’yidagi prototipga ega bo’lgan do’stona operatsiya funktsiyadan foydalanish etarli.

Friend Complex operator+ (Complex, Complex);

Sinfga konstruktor qo’shish o’rniga yagona konstruktrga ikkinchi parametr qiymatini kiritish etali:

Complex (double re, double im=0.0)

{Real=re; imag=im;}

++ va amallari prefiks va postfiks shakllariga ega bo’lgani uchun bu amallarni qo’shimcha yuklash o’ziga hos hususiyatlarga ega.Misol uchun qo’yidagi programmada ++ amali pair sinfiga tegishli ob'ektlarga bir parametrli do’stona operatsiya-funktsiya yordamida qo’shimcha yuklangan:

Friend pair & operator ++ (pair&):

--amali Pair sinfining parametrsiz kompanenta funktsiyasi yordamida qo’shimcha yuklangan:

Pair&pair: operator--();

C++ kompilyatorida. C++ tilining eng birinchi varianti amalga oshirilgan shuning uchun bu kompilyator prefiks va postfiks shakllarni ajratmaydi:

Class pair

{Int N

Double x;

Friend pair& operator++(pair);

Public:

Pair (int n, double xn)

{N=n; x=xn;}

Vouid display ()

{Cont "<

Pair& operator--C

{N/=10; x/=10; return*thes;}

Pair& operator --(int k)

{N/=2; X/=2.0; return*this;}

Pair& operator++(pair& p)

P.N*=10; P.x*=10;

Return P;

}

Pair& operator ++(pair& P, int k)

{P.N=P.N*2+k;

P.x=P.x*2+k;

Return P;}

Void mein ()

{Pair Z (10,20,0)

Z.display ();

++ 2;

Z.display ();

--Z;

Z.display ();

Z ++

Z.display ();

Z --;

Z.display ();

}

Dastur bajarilishi natijalari:

Koordinatalar: N=10 X=20

Koordinatadar: N=100 X=200

Koordinatalar: N= 10 X=20

Koordinatalar: N=20 X=40

Koordinatalar: N=10 X=20

Bu misolda prefiks ++ qiymatni 10 marta oshirishni postfiks ++ bo’lsa 2 marta oshirishni bildiradi. Prefiks -- qiymatni 10 marta kamaytirish, postfiks – bo’lsa qiymatni 20 marta kamaytirishni bildiradi.