{"id":1122,"date":"2024-01-17T17:40:47","date_gmt":"2024-01-17T12:40:47","guid":{"rendered":"https:\/\/yarat.uz\/?p=1122"},"modified":"2025-03-19T15:27:04","modified_gmt":"2025-03-19T10:27:04","slug":"funksiyalar","status":"publish","type":"post","link":"https:\/\/yarat.uz\/?p=1122","title":{"rendered":"Funksiyalar"},"content":{"rendered":"

Funksiya tushunchasi<\/strong><\/p>\n

Ma’lumki, Arduinoda har qanday skechda 2 ta majburiy funksiya<\/strong> mavjud bo’ladi: “setup()” va “loop()” funksiyalari. Lekin bulardan tashqari, skechda foydalanuvchi o’z funksiyalari<\/strong>dan hamda biblioteka funksiyalari<\/strong>dan ham foydalanishi mumkin. Biblioteka funksiyalaridan foydalanish ham foydalanuvchi funksiyalariga o’xshash tarzda amalga oshiriladi. Lekin, biblioteka funksiyalari asosiy sketchdan tashqari fayllarda hosil qilinganligi sababli, bunday funksiyalardan foydalanishdan oldin sketchning boshlang’ich sohasida mazkur fayllar (bibliotekalar)ni “#include”<\/strong> operatori yordamida qo’shib olish talab etiladi.<\/p>\n

Quyida Arduino IDE da (C++ dasturlash tilida) qo’llaniladigan funksiyalarni shartli ravishda bir necha turlarga ajratamiz va ular bilan tanishamiz.<\/p>\n

Funksiya<\/strong> – bu dasturning alohida nomga ega bo’lgan qismi.<\/p>\n

Katta xajmli dastur bilan ishlashni soddalashtirish uchun uni funksiyalarga ajratish maqsadga muvofiq. Bundan tashqari, dastur davomida ko’p marta takrorlanadigan kodlar majmuasini, alohida funksiyaga ajratib olish mumkin. Natijada funksiyani qayta-qayta ishga tushirish (chaqirish) uchun dastur davomida faqat uning nomini ko’rsatish yetarli bo’ladi. Funksiyadan foydalanishning yana bir afzalligi, ko’p foydalaniladigan funksiya xotiradan faqat 1 marta joy egallashi sababli, qurilmaning flesh-xotirasini iqtisod qilishga ham yordam beradi.
\nFunksiya boshqa funksiyalardan alohida holda keltirilishi kerak. Shundan keyin uni nomi bo’yicha chaqirish mumkin bo’ladi. Funksiya quyidagi tuzilishga ega bo’ladi:<\/p>\n

qiymat_turi funksiya_nomi<\/strong> (argumentlar) {
\nfunksiya_kodi<\/p>\n

Bu yerda:
\nqiymat_turi<\/strong> – funksiya natijasida o’zlashtiriladigan qiymatning turi, funksiya_nomi<\/strong> – funksiyani chaqirish uchun ishlatiladigan nom, argumentlar<\/strong> – funksiya ichida qo’llaniladigan o’zgaruvchilar ro’yxati (qo’llanilishi majburiy emas), funksiya_kodi<\/strong> – funksiya ichida bajariladigan amallar ketma-ketligi.<\/p>\n

Agar funksiya argumentlarga ega bo’lmasa, uni chaqirishda “()<\/strong>” (qavs) belgilarini ham tushirib qoldirish munkin (Lekin, funksiyani e’lon qilishda, argumentga ega bo’lmagan taqdirda ham, () belgilari ko’rsatilishi shart).<\/p>\n

Agar funksiya argumentlarga ega bo’lsa, uni chaqirish quyidagicha bajariladi:<\/p>\n

funksiya_nomi<\/strong>(1-argument, 2-argument, …);<\/p>\n

Funksiya har doim natijani o’zida saqlaydi. Agar funksiya bajarilishi natijasini biron o’zgaruvchiga o’zlashtirish talab qilinsa, funksiyani chaqirish quyidagi tuzilishga ega bo’lishi kerak (argumentga ega bo’lishi yoki ega emasligidan qat’iy nazar):<\/p>\n

natija = funksiya_nomi<\/strong>();<\/p>\n

Funksiyaning asosiy turlari<\/strong><\/p>\n

Funksiya argument qabul qilishi yoki qabul qilmasligi, shuningdek uning natijasi o’zgaruvchiga o’zlashtirlishi yoki o’zlashtirilmasligi mumkin. Shulardan kelib chiqib, funksiyani 4 ta asosiy turlarga bo’lish mumkin. Quyida ularning har birini misol asosida ko’rib chiqamiz:<\/p>\n

1) Argument qabul qilmaydigan va natijani qaytarmaydigan funksiya<\/strong> (ayrim boshqa dasturlash turlarida bunday funksiyani protsedura<\/strong> deb ataladi).<\/p>\n

Bunday funksiyani e’lon qilishda “void”<\/strong> (“bo’shliq”) deb nomlangan qiymat turi qo’llaniladi. Bizga ma’lum bo’lgan “setup” va “loop” majburiy funksiyalari ham ushbu turga mansub.<\/p>\n

Misol tariqasida 2 ta sonni yig’indisini hisoblab, natijani o’zgaruvchiga o’zlashtiradigan funksiyani ko’rib chiqamiz.<\/p>\n

<\/span>Misol<\/div>
\nbyte a, b;
\nint c;
\nvoid setup(){
\nSerial.begin(9600);
\na = 15;
\nb = 25;
\nyigindiniHisoblash();
\nSerial.println(c); \/\/port monitorida 40 natijasi (yig’indi) ko’rsatiladi.
\n}<\/p>\n

void loop(){
\n}<\/p>\n

void yigindiniHisoblash() {
\nc = a + b;}<\/div><\/div>\n

Bunday turdagi funksiyadan foydalanish va uni tushunish juda oson, lekin optimallik nuqtai nazaridan qaraganda qo’pol hisoblanadi. Chunki, bunday usulda o’zgaruvchilardan funksiya ichida va tashqarisida foydalanish uchun ularni global o’zgaruvchi sifatida e’lon qilishga to’g’ri keladi, chunki bunday funksiya yuqorida aytilganidek, natijani qaytarmaydi. Shuning uchun, funksiya natijasini, global o’zlashtirishga to’g’ri keladi. Global o’zgaruvchilar esa, qurilma tezkor (SRAM) xotirasidan joy band qiladi (bu joy qurilma ishi davomida doim band turadi). Bunday funksiyadan foydalanish, ayniqsa tezkor xotirasi xajmi kichik bo’lgan mikrokontrollerlar uchun to’g’ri kelmasligi mumkin.<\/p>\n

2) Argument qabul qilmaydigan lekin natijani qaytaradigan funksiya.<\/strong><\/p>\n

Natijani qaytaradigan funksiyani e’lon qilish uchun, uning qaytaradigan natijasi qiymati turi oldindan ma’lum bo’lishi kerak. Aks holda, dasturda xatolik yuz berishi mumkin.
\nMasalan, yuqoridagi misoldagi a<\/strong> va b<\/strong> o’zgaruvchilari qiymati byte<\/em><\/strong> (0 dan 255 gacha qiymat qabul qiladi) turiga mansub, c<\/strong> esa, int<\/em><\/strong> (-32768 dan 32768 gacha) turiga mansub. Agar c<\/strong> ham byte<\/em><\/strong> turiga mansub bo’lganida hamda a<\/strong> va b<\/strong> o’zgaruvchilarining qiymatlari yig’indisi 255 dan ortib ketganida, xatolik yuz bergan bo’lar edi. Shuning uchun ham c<\/strong> o’zgaruvchisi uchun int<\/em><\/strong> turi qo’llanildi.<\/p>\n

Ushbu funksiya turida, natija qaytarilishi uchun, funksiya oxirida return<\/strong> operatoridan foydalaniladi. Ushbu operator nafaqat natijani qaytaradi, balki funksiya bajarilishini ham yakunlaydi (return operatoridan, yuqoridagi void<\/strong> turidagi funksiyani yakunlash uchun ham foydalanish mumkin, biroq bunda funksiya turidan kelib chiqib, natija baribir qaytarilmaydi).<\/p>\n

Yuqoridagi misolni, natijani qaytaradigan funksiya uchun o’zgartiramiz:<\/p>\n

<\/span>Misol<\/div>
\nbyte a, b;
\nvoid setup(){
\nint c;
\nSerial.begin(9600);
\na = 15;
\nb = 25;
\nc = yigindiniHisoblash();
\n<\/strong>Serial.println(c);
\n}<\/p>\n

void loop(){
\n}<\/p>\n

int<\/strong> yigindiniHisoblash() {
\nreturn (a + b);<\/strong>
\n}<\/div><\/div>\n

Ko’rinib turibdiki, ushbu misolda c<\/strong> o’zgaruvchisi “setup” funksiyasi ichida lokal o’zgaruvchi sifatida e’lon qilingan. Funksiya ichida e’lon qilingan o’zgaruvchidan boshqa funksiyalarda foydalanib bolmaydi, lekin u tezkor xotiradan ham doimiy joy talab qilmaydi. Aniqrogi, funksiya ishi yakunlanganidan keyin, xotiradan o’chib ketadi. Lekin, agar c <\/strong>o’zgaruvchisining qiymatidan boshqa funksiyalarda ham foydalanish zarur bo’lsa, uni ham global o’zgaruvchi sifatida e’lon qilinishi kerak.<\/p>\n

3) Argumentlar qabul qiladigan va natijani ham qaytaradigan funksiya.<\/strong><\/p>\n

Ushbu funksiyani chaqirish va e’lon qilishda, ham uning argumentlari, ham qaytaradigan natija qiymati turi oldindan ma’lum bo’lishi kerak. Aks holda, dasturda xatolik yuz berishi mumkin.<\/p>\n

Funksiyani e’lon qilishda argumentlar yangi o’zgaruvchilar yordamida, ularning qiymat turi va nomini ko’rsatgan holda vergul belgisi bilan ajratib ko’rsatiladi. Funksiya chaqirilgan paytda, uning argumentlari funksiya ichida foydalanilishi mumkin bo’lgan lokal o’zgaruvchilarga aylanadi. Ya’ni dastlabki o’zgaruvchilarning qiymati funksiya ichidagi yangi o’zgaruvchilarga nusxalanadi.<\/p>\n

Yana, yuqoridagi misolni o’zgartiramiz:
\n

<\/span>Misol<\/div>
\nvoid setup(){
\nbyte a, b;
\nint c;
\nSerial.begin(9600);
\na = 15;
\nb = 25;
\nc = yigindiniHisoblash(a, b);
\n<\/strong>Serial.println(c);
\n}<\/p>\n

void loop(){
\n}<\/p>\n

int<\/strong> yigindiniHisoblash(byte a1, byte b1<\/strong>) {
\nreturn (a1 + b1);<\/strong>
\n}<\/div><\/div>\n

Ko’rinib turibdiki, ushbu misolda a, b, c<\/strong> o’zgaruvchlarning barchasi “setup” funksiyasi ichida lokal o’zgaruvchi sifatida e’lon qilingan. Demak, kod yanada optimallashdi.<\/p>\n

Muhim eslatma.
\nfunksiyani chaqirishda argument sifatida o’zgaruvchi o’rniga bir yola sonlardan ham foydalanish mumkin:<\/p>\n

c = yigindiniHisoblash(15, 25);<\/p>\n

Lekin shuni unutmaslik kerakki, Arduinoda turi e’lon qilinmagan qiymatlar int<\/strong><\/em> turiga mansub deb qaraladi. Natijada, int<\/strong><\/em> turidagi ushbu qiymatlar funksiyaning yangi o’zgaruvchilari turi (<\/em>byte<\/em><\/strong>)<\/em> dan farq qilib qoladi va xatolik yuz berishi mumkin! Masalan, quyidagi ifoda yuqoridagi misolga tatbiq etilsa, xatolik yuz beradi:<\/p>\n

c = yigindiniHisoblash(150, 250); \/\/150 va 250 int<\/em> turiga, a1 va b1 lar qiymati esa byte<\/em> turiga mansub.<\/p>\n

Xatolikning oldini olish uchun, funksiyani chaqirish paytida argumentlarning qiymat turini byte<\/strong><\/em> sifatida aniq ko’rsatish mumkin:<\/p>\n

c = yigindiniHisoblash(byte(150), byte(250));<\/p>\n

Funksiya universalligini saqlash uchun, yaxshisi uni e’lon qilishda ham byte<\/strong><\/em> o’rniga int <\/strong><\/em>turini ko’rsatish maqsadga muvofiq bo’ladi:<\/p>\n

int<\/strong> yigindiniHisoblash(int <\/strong>a1, int <\/strong>b1) {
\nreturn (a1 + b1);
\n}<\/p>\n

Yuqoridagi misollarning barchasida byte<\/strong><\/em> va int<\/strong><\/em> qiymat turlaridan foydalanildi. Agar o’zgaruvchilar qiymat turi har xil bo’lsa, dasturni tegishli ravishda o’zgartirish kerak bo’ladi:<\/p>\n

<\/span>Misol<\/div>
\nvoid setup(){
\nint a, b;
\nfloat c;
\nSerial.begin(9600);
\na = 15; b = 25;
\nc = yigindiniHisoblash((float)a, (float)b);
\n<\/strong>Serial.println(c); \/\/natija: 60.00
\n}<\/p>\n

void loop(){
\n}<\/p>\n

float<\/strong> yigindiniHisoblash(float <\/strong>a1,\u00a0float <\/strong>b1) {
\nreturn (a1 + b1);
\n}<\/div><\/div>\n

4) Argument qabul qiladigan lekin natijani qaytarmaydigan funksiya<\/strong>.<\/p>\n

Bunday funksiya ham yuqoridagi 1-turdagi funksiya bilan deyarli bir xil ishlaydi, farqi uni chaqirishda funksiya argumentlarini ham ko’rsatiladi. E’lon qilishda esa, “void”<\/strong> deb nomlangan qiymat turi qo’llaniladi. Shu nuqtai nazardan qaraganda, 1-funksiya ushbu 4-funksiyaning xususiy holati deb qaralishi ham mumkin.<\/p>\n

<\/span>Misol<\/div>
\nint c;
\nvoid setup(){
\nbyte a, b;
\nSerial.begin(9600);
\na = 15;
\nb = 25;
\nyigindiniHisoblash(a, b);
\nSerial.println(c); \/\/port monitorida 40 natijasi (yig’indi) ko’rsatiladi.
\n}<\/p>\n

void loop(){
\n}<\/p>\n

void yigindiniHisoblash(byte a1, byte a2) {
\nc = a1 + a2;
\n}
\n<\/div><\/div>\n

Demak, ushbu holda a<\/strong> va b<\/strong> lokal o’zgaruvchilari funksiyaning argumenti sifatida ko’rsatilib, natija global c<\/strong> o’zgaruvchisi orqali qaytarilyapti. Ushbu funksiya natijani qaytarmasa-da, natija o’zlashtirilgan o’zgaruvchi global e’lon qilinganligi sababli, uning qiymatidan boshqa funksiyalarda ham foydalanilishi mumkin.<\/p>\n

Funksiyaning boshqa ayrim turlari<\/strong><\/p>\n

C++ dasturlash tilida (Arduinoda ham) haddan tashqari yuklangan funksiya<\/strong> (“\u043f\u0435\u0440\u0435\u0433\u0440\u0443\u0436\u0435\u043d\u043d\u0430\u044f \u0444\u0443\u043d\u043a\u0446\u0438\u044f”) deb ataladigan funksiya ham farqlanadi.<\/p>\n

Haddan tashqari yuklangan funksiya<\/strong> deganda, bir xil nom bilan e’lon qilingan, lekin har xil qiymat turidagi natijalarni qaytaradigan yoki turlicha sondagi argumentlarga ega bo’lgan funksiya tushuniladi. Bir yo’la misolga o’tamiz:
\n

<\/span>Misol<\/div>
\nint<\/span> a;
\n<\/span>float<\/span> f;
\n<\/span>void<\/span> setup<\/span>()<\/span> {
\n<\/span>float<\/span> f1 = <\/span>2<\/span>.5;
\n<\/span><\/strong>float<\/span> f2 = <\/span>0.25<\/span>;
\n<\/span><\/strong>Serial.<\/span>begin<\/span>(<\/span>9600<\/span>)<\/span>;
\n<\/span>a = <\/span>yigindiniHisoblash(<\/span>15, 25<\/span>)<\/span>; <\/span>\/\/ natija 40
\n<\/span>a = <\/span>yigindiniHisoblash<\/span>(<\/span>15, 25, 35<\/strong><\/span>)<\/span>; <\/span>\/\/ natija 75
\n<\/span>f = <\/span>yigindiniHisoblash<\/span>(<\/span>f1, f2<\/span>)<\/span>; <\/span>\/\/ \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442 2.75
\n<\/span>Serial.<\/span>println<\/span>(<\/span>a<\/span>)<\/span>;
\n<\/span>Serial.<\/span>println<\/span>(<\/span>f<\/span>)<\/span>;
\n<\/span>}<\/span><\/p>\n
\n
\n
void<\/span> loop<\/span>()<\/span> {<\/span><\/div>\n<\/div>\n
\n
}<\/span><\/div>\n<\/div>\n
\n
<\/div>\n<\/div>\n
\n
int<\/span> yigindiniHisoblash<\/span>(<\/span>int<\/span> a1 <\/span>int<\/span> a2<\/span>)<\/span> {<\/span><\/div>\n<\/div>\n
\n
return<\/span> (<\/span>a1 + a2<\/span>)<\/span>;<\/span><\/div>\n<\/div>\n
\n
}<\/span><\/div>\n<\/div>\n
\n
<\/div>\n<\/div>\n
\n
int<\/span> yigindiniHisoblash<\/span>(<\/span>int<\/span> a1, <\/span>int<\/span> a2, <\/span>int<\/span> a3<\/span>)<\/span> {<\/span><\/div>\n<\/div>\n
\n
return<\/span> (<\/span>a1 + a2 + a3<\/span>)<\/span>;<\/span><\/div>\n<\/div>\n
\n
}<\/span><\/div>\n<\/div>\n
\n
<\/div>\n<\/div>\n
\n
float<\/span> yigindiniHisoblash<\/span>(<\/span>float<\/span> a1, <\/span>float<\/span> a2<\/span>)<\/span> {<\/span><\/div>\n<\/div>\n
\n
return<\/span> (<\/span>a1 + a2<\/span>)<\/span>;<\/span><\/div>\n<\/div>\n
\n
}
\n<\/div><\/div>\n<\/span><\/div>\n<\/div>\n<\/div>\n

Bu yerda bir xil nomli funksiya 3 xil usulda chaqirilganda 3 xil natija qaytariladi. Dastur ko’rsatilgan argumentlar soni va ularning qiymat turlariga qarab, kerakli funksiyani o’zi chaqiradi va tegishli natijani qaytaradi: argument sifatida 2 ta butun son ko’rsatilsa 1-funksiya, 3 ta butun son ko’rsatilsa 2-funksiya va float<\/strong><\/em> turli o’zgaruvchilar ko’ratilsa 3-funksiya bajariladi.<\/p>\n

O’zgaruvchining qiymatiga o’zgartirish kiritadigan funksiya<\/strong> – bu funksiyani chaqirish paytida argument sifatida ko’rsatilgan o’zgaruvchining dastlabki qiymatini o’zgartiradigan funksiya hisoblanadi.<\/p>\n

Oldingi funksiyalar bo’yicha misollardan ma’lumki, funksiyani e’lon qilish paytida e’lon qilingan yangi o’zgaruvchilar qiymatlari funksiyani chaqirish paytida argument sifatida ko’rsatilgan o’zgaruvchilarning qiymatlaridan nusxalangan edi. Funksiya kodidagi amallar esa faqat yangi lokal o’zgaruvchilar ustida bajarilgan. Ya’ni, oldingi o’zgaruvchilar qiymatiga ta’sir qilmagan. Navbatdagi turdagi funksiya bajarilishi natijasida aynan dastlabki o’zgaruvchi qiymati o’zgaradi. Buning uchun funksiyada dastlabki o’zgaruvchi qiymatini havola<\/strong> (“\u0441\u0441\u044b\u043b\u043a\u0430”) sifatida ko’rsatiladi. Natijada, funksiyaning ichida yangi o’zgaruvchi ustida bajarilgan amallar aslida dastlabki o’zgaruvchi qiymatini o’zgartiradi. Havolani ko’rsatishda funksiyani e’lon qilish paytida yangi o’zgaruvchi qiymat turi oxiriga &<\/strong> (ampersand) belgisi qo’shilishi yetarli. Misol:<\/p>\n

<\/span>Misol<\/div>
\nvoid setup(){
\nbyte a, b;
\nint c;
\nSerial.begin(9600);
\na = 15;
\nb = 25;
\nyigindiniHisoblash(a, b);
\nSerial.println(a); \/\/natija: 10
\n<\/strong>Serial.println(b); \/\/natija: 20
\n<\/strong>Serial.println(c); \/\/natija: 30
\n<\/strong>}<\/p>\n

void loop(){
\n}<\/p>\n

void<\/strong> yigindiniHisoblash(byte& a1, byte& b1<\/strong>) {
\na1=a1-5; <\/strong>\/\/a1<\/strong> ning o’zgarishi havola asosida a<\/strong> o’zgaruvchining qiymati o’zgarishiga olib keladi
\nb1=b1-5;<\/strong> \/\/b1<\/strong> ning o’zgarishi havola asosida b<\/strong> o’zgaruvchining qiymati o’zgarishiga olib keladi
\nc=a1+b1; <\/strong>\/\/yig’indi a<\/strong> va b<\/strong> ning o’zgargan qiymatlari asosida hisoblanadi
\n}
\n<\/div><\/div>\n

Funksiya yordamida har xil qiymat turiga mansub o’zgaruvchilar bilan ishlash
\n<\/strong><\/p>\n

Dastur davomida har xil turdagi o’zgaruvchilar qiymati bilan ishlash jarayonini yagona funksiyani yaratish orqali ham bajarish mumkin. Masalan, bizga int<\/strong> va float<\/strong> turidagi qiymatlar berilgan bo’lsin, 2 xil funksiya bajarilishi natijalarini (ularning yig’indisini va matn sifatida birlashtirilgan holatini) port monitoriga chiqaramiz:<\/p>\n

<\/span>Misol<\/div>
\nvoid setup(){
\nSerial.begin(9600);
\nSerial.println(yigindiniHisoblash(25, 3.25));\u00a0 \/\/natija: 28.25
\nSerial.println(matngaAylantirish(25, 3.25));\u00a0 \/\/”25 va\u00a0 3.25 sonlari birlashdi” matni ko’rinadi
\n}<\/p>\n

void loop(){
\n}<\/p>\n

float<\/span> yigindiniHisoblash(int a, float b) {
\n\u00a0 return<\/span> ((float)a+b);
\n}<\/p>\n

String<\/span> matngaAylantirish(int a, float b) {
\n\u00a0 return<\/span> ((String)a + ” va ” + b + ” sonlari birlashdi”);
\n}
\n<\/div><\/div>\n

Funksiyadan bir nechta natijalarni qaytarish
\n<\/strong><\/p>\n

Umuman olganda, C++ da (Arduinoda ham) funksiyadan bir nechta natijani qaytarish tushunchasi yo’q. Lekin, struktura yordamida murakkabroq bo’lsa-da, shunday “qo’lbola” funksiyani yaratsa bo’ladi.<\/p>\n

Struktura o’zi nima?<\/p>\n

Struktura<\/strong> (struct) – har xil qiymat turlari asosidagi o\u2019zgaruvchilarning bir nom ostida va alohida qiymat turi sifatida e\u2019lon qilinishi hisoblanadi.<\/p>\n

Struktura bilan ishlash quyidagi tartibda amalga oshiriladi:<\/p>\n

1) Global o’zgaruvchilar sohasida yangi struktura turi<\/strong> (yorlig’i) va uning tarkibidagi o’zgaruvchilar e’lon qilinadi;
\n2) E’lon qilingan struktura turi asosida funksiya yaratiladi (turlarini ko’rsatgan holda kerakli argumentlar ham sanab o’tiladi) va kerakli amallar kodi keltiriladi, natijalar umumlashgan holda struktura nomiga o’zlashtiriladi;
\n3) Asosiy kodda struktura nomi bo’yicha e’lon qilinadi va kerakli funksiyani chaqiruvchi kod kiritiladi.<\/p>\n

Tushunarli bo’lishi uchun misolni batafsil izohlari bilan misol keltiramiz:<\/p>\n

<\/span>Strukturaga misol<\/div>
\n\/\/funksiya natijalari float turida bo’lishini hisobga olib, barcha o’zgaruvchilarni shu tur bilan e’lon qilinadi!<\/p>\n

struct Amallar<\/strong> { \/\/”Amallar” nomli struktura turi (yorlig’i) e’lon qilinmoqda
\nfloat qushish; \/\/float turli qiymatni qabul qiluvchi “qushish” o’zgaruvchisi e’lon qilinmoqda
\nfloat ayirish; \/\/float turli qiymatni qabul qiluvchi “ayirish” o’zgaruvchisi e’lon qilinmoqda
\nfloat kupaytirish; \/\/float turli qiymatni qabul qiluvchi “kupaytirish” o’zgaruvchisi e’lon qilinmoqda
\nfloat bulish; \/\/float turli qiymatni qabul qiluvchi “bulish” o’zgaruvchisi e’lon qilinmoqda
\n};<\/p>\n

void setup {
\nSerial.begin(9600);
\nAmallar amal;<\/strong> \/\/”Amallar” umumlashgan turi asosida “amal” nomli struktura e’lon qilinmoqda
\namal<\/strong> = hisoblash<\/strong>(5, 15.25); \/\/”hisoblash” nomli funksiya argumentlari ko’rsatilgan holda chaqirilmoqda va natija “amal” nomli strukturaga o’zlashtirilmoqda;<\/p>\n

Serial.println(amal.qushish<\/strong>); \/\/strukturadagi 1-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
\nSerial.println(amal.ayirish<\/strong>); \/\/strukturadagi 2-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
\nSerial.println(amal.kupaytirish<\/strong>); \/\/strukturadagi 3-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
\nSerial.println(amal.bulish<\/strong>); \/\/strukturadagi 4-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
\n}<\/p>\n

void loop(){
\n}<\/p>\n

Amallar hisoblash(int a, float b){ \/\/Amallar turli (yorliqli) ‘hisoblash’ funksiyasi e’lon qilinmoqda
\nAmallar amal;<\/strong> \/\/’amal’ nomli ichki struktura e’lon qilinmoqda
\namal.qushish = (float)a + b;<\/strong> \/\/struktura o’zgaruvchilariga qiymatlar o’zlashtirilmoqda;
\namal.ayirish = b-(float)a;<\/strong> \/\/struktura o’zgaruvchilariga qiymatlar o’zlashtirilmoqda;
\namal.kupaytirish = (float)a * b;<\/strong> \/\/struktura o’zgaruvchilariga qiymatlar o’zlashtirilmoqda;
\namal.bulish = b\/(float)a;<\/strong> \/\/struktura o’zgaruvchilariga qiymatlar o’zlashtirilmoqda;
\nreturn amal;<\/strong> \/\/’amal’ strukturasiga o’zlashtirilgan qiymatlar qaytarilmoqda
\n}
\n<\/div><\/div>\n

Yuqoridagi misolda biz int<\/strong> va float<\/strong> turli 2 ta son ustidagi 4 ta amallarni bajaruvchi “hisoblash” nomli funksiyani yaratdik.<\/p>\n

Funksiyani tavsiflash va realizatsiya qilish<\/strong><\/p>\n

Yuqorida keltirilgan misollarning barchasida biz funksiyaning qanday e’lon qilinishi va chaqirilishini ko’rib chiqdik. Arduino bibliotekalarini yaratishda va umuman, kodni optimallashtirish maqsadida funksiyaning e’lon qilinishi (tavsiflash<\/strong>) va amalga oshirilishi (realizatsiya<\/strong>) ni ajratib qo’yish tavsiya etiladi. Ya’ni, loyiha boshida uni tavsiflanadi, boshqa joyida (xususan, unga ilova qilingan alohida faylda ham bo’lishi mumkin) realizatsiya qilinadi.<\/p>\n

<\/span>Tavsiflashga misol<\/div>
\n

int c=0;
\nint<\/span> yigindiniHisoblash(byte a, byte b);
\nvoid<\/span> ayirma(byte a, byte b);<\/p>\n

<\/div><\/div><\/span><\/p>\n

<\/span>Realizatsiyaga misol<\/div>
\n

int<\/span> yigindiniHisoblash(byte a, byte b) {
\nreturn a+b;
\n}<\/p>\n

void<\/span> ayirma(byte a, byte b){
\nc=a-b;
\n}<\/p>\n

<\/div><\/div><\/span><\/p>\n

Ko’rinib turibdiki, tavsiflash realizatsiyaning boshlang’ich qismidan iborat xolos. Lekin asosiy qoida shundan iboratki, tavsiflash aynan loyiha boshida amalga oshirilishi kerak, shundan keyin realizatsiyani hatto boshqa fayl yoki bibliotekaga ham ko’chirib qo’yish mumkin (boshqa fayldan qo’shib olish uchun uning nomini #include<\/strong> operatori orqali e’lon qilish ham talab etiladi).<\/p>\n

Shablonli funksiyalar<\/strong><\/p>\n

Shablonli funksiya<\/strong> – bu har qanday qiymat turi bilan ishlay oladigan funksiya hisoblanadi. Berilgan qiymatdan kelib chiqib kompilyatorning o’zi uning qanday turga mansubligini aniqlaydi va zarurat bo’lsa, bir nechta haddan tashqari yuklangan funksiya yaratib olishi mumkin.<\/p>\n

Shablonli funksiya quyidagicha e’lon qilinadi:<\/p>\n

template<\/span> <<\/span>shablon_parametrlari<\/span>><\/span> funksiya_tavsifi<\/span><\/p>\n

funksiya tavsifi<\/span>ni kengaytirib ko’rsatish mumkin:<\/div>\n

template<\/span> <<\/span>shablon_paramterlari<\/span>><\/span> qiymat_turi <\/span>(<\/span>argumentlar<\/span>)<\/span> {<\/span>
\nfunksiya_kodi<\/span>
\n}<\/span>
\nMisol sifatida har qanday turdagi sonning kvadratini hisoblash funksiyasini yaratamiz:<\/p>\n

<\/span>Shablonli funksiya<\/div>
\ntemplate<\/span><<\/span>typename<\/span> shablon<\/span>><\/span>
\nshablon <\/span>kvadrat<\/span>(<\/span>shablon son<\/span>)<\/span> {<\/span>
\nreturn<\/span> son * son;<\/span>
\n}<\/span>
\nvoid<\/span> setup<\/span>()<\/span> {
\n<\/span> byte a = 10;
\n<\/span>int<\/span> b = 125;
\n<\/span>float<\/span> c = <\/span>3.14<\/span>;
\n<\/span> a = <\/span>kvadrat<\/span>(<\/span>a<\/span>)<\/span>; \/\/natija: 100
\n<\/span> b = <\/span>kvadrat<\/span>(<\/span>b<\/span>)<\/span>; \/\/natija: 15625
\n<\/span> c = <\/span>kvadrat<\/span>(<\/span>c<\/span>)<\/span>; \/\/natija: 9,85
\n<\/span>\/\/ a == 100
\n<\/span>\/\/ b == 15625
\n<\/span>\/\/ c == 9.85
\n<\/span>}
\n<\/div><\/div>\n<\/span><\/p>\n
Shablonga yanada ko’proq qiymatlar turini uzatish mumkin. Ixtiyoriy turlarga mansub bo’lgan ikkita sonning ko’paytmasini hisoblovchi funksiyaga misol:<\/div>\n
\n
<\/span>Shablonli funksiya<\/div>
\ntemplate<\/span><<\/span>typename<\/span> T1, <\/span>typename<\/span> T2<\/span>> \/\/ikki argumentli shablon e’lon qilinyapti
\n<\/span>uint32_t<\/span> kupaytirish<\/span>(<\/span>T1 a1, T2 b1<\/span>)<\/span> { \/\/ixtiyoriy turli 2 ta sonni ko’paytirish funksiyasi e’lon qilinyapti
\n<\/span>return<\/span> a1 * b1;
\n<\/span>}
\n<\/span>void<\/span> setup<\/span>()<\/span> {
\n<\/span>byte a = 10;
\n<\/span>int<\/span> b = 125;
\n<\/span>float<\/span> c = <\/span>3.14<\/span>;
\n<\/span>long<\/span> d = <\/span>kupaytirish<\/span>(<\/span>a, b<\/span>)<\/span>;
\n<\/span>d = <\/span>kupaytirish<\/span>(<\/span>a, c<\/span>)<\/span>;
\n<\/span>}<\/div><\/div><\/span><\/p>\n<\/div>\n
\n
Shablonli funksiyani chaqirishni soddaroq ifodalash mumkin:<\/div>\n
kupaytirish<byte, <\/span>float<\/span>><\/span>(<\/span>a, b<\/span>)<\/span>;
\n<\/span><\/p>\n
Makro-funksiyalar<\/strong><\/div>\n
Makro-funksiya <\/strong>– #define<\/span><\/span> operatori yordamida e’lon qilinadigan va natijasi hisoblanadigan funksiya. Bunday funksiyani foydalanuvchi funksiyasi sifatida e’lon qilish ham shart emas. Shunchaki loyiha boshlang’ich qismidagi sohada #define<\/strong> operatorining o’ziga xos vazifasi – u orqali e’lon qilingan belgilar ketma-ketligini biz ko’rsatgan har qanday qiymat bilan almashtirishi hisoblanadi.<\/div>\n
Masalan, makrofunksiyani quyidagicha e’lon qilishimiz mumkin:<\/div>\n
\n

<\/span>Makro-funksiya<\/div>
\n<\/span><\/span>#define yigindi(x, y) ((x)+(y))
\nUning mazmuni: kompilyatsiya paytida uchragan har qanday sum(1-qiymat, 2-qiymat)<\/span> kodini “1-qiymat+2-qiymat” ga, ya’ni qiymatlarning yig’indisiga almashtiriladi:
\n#define yigindi(x, y) ((x)+(y))
\n<\/span>void<\/span> setup<\/span>()<\/span> {
\n<\/span>byte a = 10;
\n<\/span>byte b = 20;
\n<\/span>byte c = <\/span>yigindi<\/span>(<\/span>a, b<\/span>)<\/span>; \/\/natija: c=30
\n<\/span>int<\/span> d = <\/span>yigindi<\/span>(<\/span>500, 900<\/span>)<\/span>; \/\/natija: d=1400
\n<\/span>}
\n<\/span>void<\/span> loop<\/span>()<\/span> {
\n<\/span>}
\n<\/span><\/div><\/div><\/span><\/p>\n<\/div>\n
Makro-funksiyaning yana bir qulayligi – u oddiy funksiya kabi xotiradagi manzilga ega bo’lmaydi va chaqirilgan paytida to’g’ridan-tog’ri bajarilib ketiladi. Bu esa, dastur ishini tezlashtirishga yordam beradi. Shu bilan birga, uning ushbu xususiyati ba’zi vaziyatlarda uning kamchiligi ham hisoblanadi. Agar makrofunksiyani chaqirish dastur davomida juda ko’p bo’lsa, qiymatni boshqasiga almashtirishlar soni ham ko’payib ketadi va makro-funksiya xotiradan ko’proq joy oladi. Shuning uchun makro-funksiyadan o’rinli foydalanish zarur, masalan, unga murojaatlar soni kam bo’ladigan, lekin murakkab hisoblash jarayonlari bajariladigan holatlar uchun qo’llash maqsadga muvofiq.<\/div>\n<\/div>\n
<\/div>\n
Yuqorida biz funksiyalarning dasturlashdagi ahamiyati, ularning asosiy turlari va boshqa jihatlari bilan tanishib chiqdik va hozircha shu ma’lumotlar bilan sheklanamiz. Qo’shimcha ma’lumotlarni esa, har doim Internet sahifalaridan topish mumkin (Materialni tayyorlashda asosan rus tilidagi alexgyver.ru<\/a> sayti materiallaridan foydalanildi. Mazkur sayt Arduinoni o’rganish yo’nalishidagi rus internetining yetakchi saytlaridan biriga aylanib ulgurgan<\/em>).<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

Funksiya tushunchasi Ma’lumki, Arduinoda har qanday skechda 2 ta majburiy funksiya mavjud bo’ladi: “setup()” va “loop()” funksiyalari. Lekin bulardan tashqari, skechda foydalanuvchi o’z funksiyalaridan hamda biblioteka funksiyalaridan ham foydalanishi mumkin. Biblioteka funksiyalaridan foydalanish ham foydalanuvchi funksiyalariga o’xshash tarzda amalga oshiriladi. Lekin, biblioteka funksiyalari asosiy sketchdan tashqari fayllarda hosil qilinganligi sababli, bunday funksiyalardan foydalanishdan oldin sketchning […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[12],"tags":[],"class_list":["post-1122","post","type-post","status-publish","format-standard","hentry","category-qollanmalar"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts\/1122","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1122"}],"version-history":[{"count":50,"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts\/1122\/revisions"}],"predecessor-version":[{"id":4931,"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts\/1122\/revisions\/4931"}],"wp:attachment":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1122"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1122"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1122"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}