Funksiyalar

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 boshlang’ich sohasida mazkur fayllar (bibliotekalar)ni “#include” operatori yordamida qo’shib olish talab etiladi.

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

Funksiya – bu dasturning alohida nomga ega bo’lgan qismi.

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.
Funksiya boshqa funksiyalardan alohida holda keltirilishi kerak. Shundan keyin uni nomi bo’yicha chaqirish mumkin bo’ladi. Funksiya quyidagi tuzilishga ega bo’ladi:

qiymat_turi funksiya_nomi (argumentlar) {
funksiya_kodi

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

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

Agar funksiya argumentlarga ega bo’lsa, uni chaqirish quyidagicha bajariladi:

funksiya_nomi(1-argument, 2-argument, …);

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):

natija = funksiya_nomi();

Funksiyaning asosiy turlari

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:

1) Argument qabul qilmaydigan va natijani qaytarmaydigan funksiya (ayrim boshqa dasturlash turlarida bunday funksiyani protsedura deb ataladi).

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

Misol tariqasida 2 ta sonni yig’indisini hisoblab, natijani o’zgaruvchiga o’zlashtiradigan funksiyani ko’rib chiqamiz.

Misol

byte a, b;
int c;
void setup(){
Serial.begin(9600);
a = 15;
b = 25;
yigindiniHisoblash();
Serial.println(c); //port monitorida 40 natijasi (yig’indi) ko’rsatiladi.
}

void loop(){
}

void yigindiniHisoblash() {
c = a + b;}

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.

2) Argument qabul qilmaydigan lekin natijani qaytaradigan funksiya.

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.
Masalan, yuqoridagi misoldagi a va b o’zgaruvchilari qiymati byte (0 dan 255 gacha qiymat qabul qiladi) turiga mansub, c esa, int (-32768 dan 32768 gacha) turiga mansub. Agar c ham byte turiga mansub bo’lganida hamda a va b o’zgaruvchilarining qiymatlari yig’indisi 255 dan ortib ketganida, xatolik yuz bergan bo’lar edi. Shuning uchun ham c o’zgaruvchisi uchun int turi qo’llanildi.

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

Yuqoridagi misolni, natijani qaytaradigan funksiya uchun o’zgartiramiz:

Misol

byte a, b;
void setup(){
int c;
Serial.begin(9600);
a = 15;
b = 25;
c = yigindiniHisoblash();
Serial.println(c);
}

void loop(){
}

int yigindiniHisoblash() {
return (a + b);
}

Ko’rinib turibdiki, ushbu misolda c 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 o’zgaruvchisining qiymatidan boshqa funksiyalarda ham foydalanish zarur bo’lsa, uni ham global o’zgaruvchi sifatida e’lon qilinishi kerak.

3) Argumentlar qabul qiladigan va natijani ham qaytaradigan funksiya.

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.

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.

Yana, yuqoridagi misolni o’zgartiramiz:

Misol

void setup(){
byte a, b;
int c;
Serial.begin(9600);
a = 15;
b = 25;
c = yigindiniHisoblash(a, b);
Serial.println(c);
}

void loop(){
}

int yigindiniHisoblash(byte a1, byte b1) {
return (a1 + b1);
}

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

Muhim eslatma.
funksiyani chaqirishda argument sifatida o’zgaruvchi o’rniga bir yola sonlardan ham foydalanish mumkin:

c = yigindiniHisoblash(15, 25);

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

c = yigindiniHisoblash(150, 250); //150 va 250 int turiga, a1 va b1 lar qiymati esa byte turiga mansub.

Xatolikning oldini olish uchun, funksiyani chaqirish paytida argumentlarning qiymat turini byte sifatida aniq ko’rsatish mumkin:

c = yigindiniHisoblash(byte(150), byte(250));

Funksiya universalligini saqlash uchun, yaxshisi uni e’lon qilishda ham byte o’rniga int turini ko’rsatish maqsadga muvofiq bo’ladi:

int yigindiniHisoblash(int a1, int b1) {
return (a1 + b1);
}

Yuqoridagi misollarning barchasida byte va int qiymat turlaridan foydalanildi. Agar o’zgaruvchilar qiymat turi har xil bo’lsa, dasturni tegishli ravishda o’zgartirish kerak bo’ladi:

Misol

void setup(){
int a, b;
float c;
Serial.begin(9600);
a = 15; b = 25;
c = yigindiniHisoblash((float)a, (float)b);
Serial.println(c); //natija: 60.00
}

void loop(){
}

float yigindiniHisoblash(float a1, float b1) {
return (a1 + b1);
}

4) Argument qabul qiladigan lekin natijani qaytarmaydigan funksiya.

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” deb nomlangan qiymat turi qo’llaniladi. Shu nuqtai nazardan qaraganda, 1-funksiya ushbu 4-funksiyaning xususiy holati deb qaralishi ham mumkin.

Misol

int c;
void setup(){
byte a, b;
Serial.begin(9600);
a = 15;
b = 25;
yigindiniHisoblash(a, b);
Serial.println(c); //port monitorida 40 natijasi (yig’indi) ko’rsatiladi.
}

void loop(){
}

void yigindiniHisoblash(byte a1, byte a2) {
c = a1 + a2;
}

Demak, ushbu holda a va b lokal o’zgaruvchilari funksiyaning argumenti sifatida ko’rsatilib, natija global c 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.

Funksiyaning boshqa ayrim turlari

C++ dasturlash tilida (Arduinoda ham) haddan tashqari yuklangan funksiya (“перегруженная функция”) deb ataladigan funksiya ham farqlanadi.

Haddan tashqari yuklangan funksiya 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:

Misol

int a;
float f;
void setup() {
float f1 = 2.5;
float f2 = 0.25;
Serial.begin(9600);
a = yigindiniHisoblash(15, 25); // natija 40
a = yigindiniHisoblash(15, 25, 35); // natija 75
f = yigindiniHisoblash(f1, f2); // результат 2.75
Serial.println(a);
Serial.println(f);
}

void loop() {

}

int yigindiniHisoblash(int a1 int a2) {

return (a1 + a2);

}

int yigindiniHisoblash(int a1, int a2, int a3) {

return (a1 + a2 + a3);

}

float yigindiniHisoblash(float a1, float a2) {

return (a1 + a2);

}

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 turli o’zgaruvchilar ko’ratilsa 3-funksiya bajariladi.

O’zgaruvchining qiymatiga o’zgartirish kiritadigan funksiya – bu funksiyani chaqirish paytida argument sifatida ko’rsatilgan o’zgaruvchining dastlabki qiymatini o’zgartiradigan funksiya hisoblanadi.

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 (“ссылка”) 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 & (ampersand) belgisi qo’shilishi yetarli. Misol:

Misol

void setup(){
byte a, b;
int c;
Serial.begin(9600);
a = 15;
b = 25;
yigindiniHisoblash(a, b);
Serial.println(a); //natija: 10
Serial.println(b); //natija: 20
Serial.println(c); //natija: 30
}

void loop(){
}

void yigindiniHisoblash(byte& a1, byte& b1) {
a1=a1-5; //a1 ning o’zgarishi havola asosida a o’zgaruvchining qiymati o’zgarishiga olib keladi
b1=b1-5; //b1 ning o’zgarishi havola asosida b o’zgaruvchining qiymati o’zgarishiga olib keladi
c=a1+b1; //yig’indi a va b ning o’zgargan qiymatlari asosida hisoblanadi
}

Funksiya yordamida har xil qiymat turiga mansub o’zgaruvchilar bilan ishlash

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

Misol

void setup(){
Serial.begin(9600);
Serial.println(yigindiniHisoblash(25, 3.25)); //natija: 28.25
Serial.println(matngaAylantirish(25, 3.25)); //”25 va 3.25 sonlari birlashdi” matni ko’rinadi
}

void loop(){
}

float yigindiniHisoblash(int a, float b) {
return ((float)a+b);
}

String matngaAylantirish(int a, float b) {
return ((String)a + ” va ” + b + ” sonlari birlashdi”);
}

Funksiyadan bir nechta natijalarni qaytarish

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.

Struktura o’zi nima?

Struktura (struct) – har xil qiymat turlari asosidagi o’zgaruvchilarning bir nom ostida va alohida qiymat turi sifatida e’lon qilinishi hisoblanadi.

Struktura bilan ishlash quyidagi tartibda amalga oshiriladi:

1) Global o’zgaruvchilar sohasida yangi struktura turi (yorlig’i) va uning tarkibidagi o’zgaruvchilar e’lon qilinadi;
2) 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;
3) Asosiy kodda struktura nomi bo’yicha e’lon qilinadi va kerakli funksiyani chaqiruvchi kod kiritiladi.

Tushunarli bo’lishi uchun misolni batafsil izohlari bilan misol keltiramiz:

Strukturaga misol

//funksiya natijalari float turida bo’lishini hisobga olib, barcha o’zgaruvchilarni shu tur bilan e’lon qilinadi!

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

void setup {
Serial.begin(9600);
Amallar amal; //”Amallar” umumlashgan turi asosida “amal” nomli struktura e’lon qilinmoqda
amal = hisoblash(5, 15.25); //”hisoblash” nomli funksiya argumentlari ko’rsatilgan holda chaqirilmoqda va natija “amal” nomli strukturaga o’zlashtirilmoqda;

Serial.println(amal.qushish); //strukturadagi 1-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
Serial.println(amal.ayirish); //strukturadagi 2-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
Serial.println(amal.kupaytirish); //strukturadagi 3-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
Serial.println(amal.bulish); //strukturadagi 4-o’zgaruvchi qiymati natija sifatida chiqarilmoqda
}

void loop(){
}

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

Yuqoridagi misolda biz int va float turli 2 ta son ustidagi 4 ta amallarni bajaruvchi “hisoblash” nomli funksiyani yaratdik.

Funksiyani tavsiflash va realizatsiya qilish

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) va amalga oshirilishi (realizatsiya) 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.

Tavsiflashga misol

int c=0;
int yigindiniHisoblash(byte a, byte b);
void ayirma(byte a, byte b);

Realizatsiyaga misol

int yigindiniHisoblash(byte a, byte b) {
return a+b;
}

void ayirma(byte a, byte b){
c=a-b;
}

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 operatori orqali e’lon qilish ham talab etiladi).

Shablonli funksiyalar

Shablonli funksiya – 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.

Shablonli funksiya quyidagicha e’lon qilinadi:

template <shablon_parametrlari> funksiya_tavsifi

funksiya tavsifini kengaytirib ko’rsatish mumkin:

template <shablon_paramterlari> qiymat_turi (argumentlar) {
funksiya_kodi
}
Misol sifatida har qanday turdagi sonning kvadratini hisoblash funksiyasini yaratamiz:

Shablonli funksiya

template<typename shablon>
shablon kvadrat(shablon son) {
return son * son;
}
void setup() {
byte a = 10;
int b = 125;
float c = 3.14;
a = kvadrat(a); //natija: 100
b = kvadrat(b); //natija: 15625
c = kvadrat(c); //natija: 9,85
// a == 100
// b == 15625
// c == 9.85
}

Shablonga yanada ko’proq qiymatlar turini uzatish mumkin. Ixtiyoriy turlarga mansub bo’lgan ikkita sonning ko’paytmasini hisoblovchi funksiyaga misol:

Shablonli funksiya

template<typename T1, typename T2> //ikki argumentli shablon e’lon qilinyapti
uint32_t kupaytirish(T1 a1, T2 b1) { //ixtiyoriy turli 2 ta sonni ko’paytirish funksiyasi e’lon qilinyapti
return a1 * b1;
}
void setup() {
byte a = 10;
int b = 125;
float c = 3.14;
long d = kupaytirish(a, b);
d = kupaytirish(a, c);
}

Shablonli funksiyani chaqirishni soddaroq ifodalash mumkin:

kupaytirish<byte, float>(a, b);

Makro-funksiyalar

Makro-funksiya – #define 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 operatorining o’ziga xos vazifasi – u orqali e’lon qilingan belgilar ketma-ketligini biz ko’rsatgan har qanday qiymat bilan almashtirishi hisoblanadi.

Masalan, makrofunksiyani quyidagicha e’lon qilishimiz mumkin:

Makro-funksiya

#define yigindi(x, y) ((x)+(y))
Uning mazmuni: kompilyatsiya paytida uchragan har qanday sum(1-qiymat, 2-qiymat) kodini “1-qiymat+2-qiymat” ga, ya’ni qiymatlarning yig’indisiga almashtiriladi:
#define yigindi(x, y) ((x)+(y))
void setup() {
byte a = 10;
byte b = 20;
byte c = yigindi(a, b); //natija: c=30
int d = yigindi(500, 900); //natija: d=1400
}
void loop() {
}

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.

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 sayti materiallaridan foydalanildi. Mazkur sayt Arduinoni o’rganish yo’nalishidagi rus internetining yetakchi saytlaridan biriga aylanib ulgurgan).

Tanishing

Добавить комментарий Отменить ответ