Arifmetik amallar
Ishlash belgisi
|
Qiymati
|
Foydalanish
|
*
|
Ko'paytirish
|
expr * expr
|
/
|
Bo'linish
|
ekspr / ekspr
|
%
|
Bo'linish qoldig'i
|
ekspr% ekspr
|
+
|
Qo'shimcha
|
expr + ekspr
|
-
|
Ajratish
|
ekspr - ekspr
|
Butun sonlarni bo'linishi butun sonni keltirib chiqaradi. Agar mavjud bo'lsa, natijaning kasr qismi tashlanadi:
int ivall = 21/6;
int iva12 = 21/7;
Ikkala ival1 va ival2 oxir-oqibat 3 qiymatini olishadi (Modulo
bo'linishi deb ham ataladi) (%) operatsiyasi birinchi operandni ikkinchi qismga bo'lishning qolgan qismini qaytaradi, lekin faqat butun sonli operandlarga tegishlidir (char, short, int, long). Agar ikkala operand ham ijobiy bo'lsa, natija ijobiy bo'ladi. Agar bitta yoki ikkala operand ham salbiy bo'lsa, natija bajarishga, ya'ni mashinaga bog'liq. Modulo bo'linmasidan to'g'ri va noto'g'ri foydalanish misollari keltirilgan:
3,14% 3; // xato: operatsiya juft tipli
21% 6; // to‘g‘ri: 3
21% 7; // to‘g‘ri: 0
21% -5; // mashinaga bog'liq: -1 yoki 1
int iva1 = 1024;
juft dval = 3.14159;
iva1% 12; // to‘g‘ri:
iva1% dval; // xato: operatsiya juft tipli
Ba'zida arifmetik ifoda hisoblash natijasi noto'g'ri yoki aniqlanmagan bo'lishi mumkin. Bunday holatlarda ular arifmetik istisnolar haqida gapirishadi (garchi ular dasturda istisno qilinishiga olib kelmasa ham). Arifmetik istisnolar sof matematik xususiyatga ega bo'lishi mumkin (aytaylik, 0 ga bo'linish) yoki kompyuterda raqamlarni ifodalashdan kelib chiqqan holda - ortiqcha oqim sifatida (agar qiymat ushbu turdagi ob'ekt tomonidan ifoda etilishi mumkin bo'lgan qiymatdan oshsa). Masalan, char turi 8 bitni o'z ichiga oladi va imzolangan yoki imzolanmaganligiga qarab 0 dan 255 gacha yoki -128 dan 127 gacha bo'lgan qiymatlarni saqlashga qodir. Quyidagi misolda, 256 turiga mos keladigan ob'ektni o'rnatishga urinish toshib ketishga olib keladi:
# o'z ichiga oladi
int main () {
char byte_value = 32;
int ival = 8;
// ajratilgan xotiraning
to'lishi byte_value byte_value = ival * byte_value;
cout << "byte_value:" << static_cast (bayt_value) << endl;
}
256ni namoyish qilish uchun 9 bit kerak. Byte_value o'zgaruvchisi aniqlanmagan (mashinaga bog'liq) qiymatga ega bo'ladi. Aytaylik, biz SGI ish stantsiyamizda ushbu qiymatni chop etishga birinchi urinish:
cout << "byte_va1ue:" << byte_va1ue << endl;
natijaga olib keldi:
bayt_val:
Biroz chalkashliklardan so'ng, biz 0 ning qiymati ASCII nol belgisi ekanligini va bosib chiqarishda hech qanday ko'rinishga ega emasligini angladik.
Belgining emas, balki uning qiymatini aks ettirish uchun biz juda g'alati ko'rinadigan ifodani ishlatishga majbur bo'ldik: static_cast (bayt_value),
bu aniq turdagi konversiya deb ataladi. Ob'ekt yoki ifoda turini dasturchi tomonidan aniq ko'rsatilgan boshqa turga o'zgartiradi. Bizning holda, biz bayt_valni int ga o'zgartirdik. Endi dastur yanada mazmunli natija beradi:
bayt_val: 0
Aslida, byte_value-ga mos keladigan qiymatni emas, balki har xil turlar uchun turlicha ishlaydigan chiqish operatsiyasining holatini o'zgartirish kerak edi. Char ob'ektlari ASCII belgilari (kodlar emas) bilan ifodalanadi, int turidagi ob'ektlar uchun biz ularning tarkibidagi qiymatlarni ko'ramiz. (Turlarning o'zgarishi 4.14 bo'limida muhokama qilinadi).
Mavzudan kichik bir chetga chiqish - bu turdagi konversion muammolarni muhokama qilish - bizning dasturimiz ishida topilgan xato tufayli kelib chiqadi va ma'lum ma'noda, dasturning anomal xatti-harakati bizni nimaga erishish maqsadi haqida bir muncha vaqt unutishga majbur qilganida, haqiqiy dasturlash jarayoniga o'xshaydi. , va ahamiyatsiz ko'rinadigan tafsilotlarga e'tibor qarating. To'liq to'ldirishga olib keladigan ma'lumot turini etarlicha o'ylanmagan tanlash kabi xato, xatoni aniqlashga olib kelishi mumkin: samaradorlik sababli dasturni bajarish paytida ortiqcha toshib ketishni tekshirish amalga oshirilmaydi.
C ++ standart kutubxonasida o'rnatilgan ma'lumotlar turlari, shu jumladan har bir tur uchun qiymat diapazoni to'g'risidagi turli xil ma'lumotlarni o'z ichiga olgan chegaralar sarlavhasi fayllari mavjud. Klimits va cfloat sarlavhalari fayllari ham ushbu ma'lumotlarni o'z ichiga oladi. (Bu sarlavhali fayllardan ortiqcha va ahamiyatini yo'qotmaslik uchun foydalanish uchun 4 va 6- boblarga qarang [PLAUGER92]).
Haqiqiy raqamlarning arifmetikasi yana bir yaxlitlash muammosini keltirib chiqaradi. Haqiqiy son bitlarning sobit soni bilan ifodalanadi (har xil turlar uchun farq qiladi - suzuvchi, er-xotin va uzun qo'shaloq) va qiymatning aniqligi ishlatilgan ma'lumot turiga bog'liq. Ammo hatto eng aniq uzunlikdagi tur ham yaxlitlashda xatolikni bartaraf eta olmaydi. Qanday bo'lmasin, haqiqiy miqdor biroz cheklangan aniqlik bilan ifodalanadi.
Yuqoridagi iboralarning bo'linish jarayoni bilan farqi nimada?
er-xotin dvall = 10,0, dva12 = 3.0;
int ivall = 10, iva12 = 3;
dvall / dva12;
ivall / iva12;
Berilgan butun sonning juft yoki toq ekanligini aniqlaydigan ifoda yozing.
Sarlavhalarning chegaralarini, klimitslarini va cfloat fayllarini toping va ularning tarkibidagi narsalarni ko'ring.
Ishlash belgisi
|
Qiymati
|
Foydalanish
|
!
|
Mantiqiy YO'Q
|
! ekspres
|
<
|
kamroq
|
expr |
<=
|
Kam yoki teng
|
expr <= expr
|
>
|
ko'proq
|
expr> expr
|
> =
|
ko'proq yoki teng
|
expr> = expr
|
==
|
teng
|
expr == ekspr
|
! =
|
teng emas
|
expr! = expr
|
&&
|
mantiqiy VA
|
expr && expr
|
||
|
mantiqiy OR
|
ekspr || expr
|
Izoh Barcha operatsiyalar natijali bool qiymatiga olib keladi
Taqqoslash va mantiqiy operatsiyalar natijasida bool, ya'ni haqiqiy yoki noto'g'ri qiymatning qiymati kelib chiqadi. Agar bunday ifoda butun sonni talab qiladigan kontekstda ro'y bersa, true 1 ga, noto'g'ri esa 0 ga o'zgartiriladi. Bu erda berilgan qiymatdan kamroq vektor elementlari sonini hisoblaydigan kod bo'lagi:
vektor :: iterator iter = ivec.beg-in ();
while (iter! = ivec.end ()) {
// ekvivalent: e1em_cnt = e1em_cnt + (* iter
// ifodaning haqiqiy / noto'g'ri qiymati * iter
// 1 yoki 0 ga aylanadi
e1em_cnt + = * iter
++ iter;
}
Biz shunchaki kam ishlash natijasini hisoblagichga qo'shamiz. (Juft + = Shu ancha ixcham yozilishi mumkin o'ng turib, chap turgan, obyekti qo'shimchalar aralashma tayinlash operatori, va operandi bildiradi:. .. Elem_count = elem_count + n Biz bo'lim 4,4 bu bayonotlar ko'rib)
Mantiqiy VA (&&) True ni faqat ikkala operand rost bo'lsa qaytaradi. Agar hech bo'lmaganda bitta operand to'g'ri bo'lsa, mantiqiy OR (||) to'g'ri beradi. Operandalarning chapdan o'ngga qarab baholanishi kafolatlanadi va hisoblash natijasi ma'lum bo'lgandan so'ng tugaydi. Bu nimani anglatadi? Ikkala ibora berilsin:
expr1 && expr2
ekspr1 || ekspr2
Agar ularning birinchisida expr1 noto'g'ri bo'lsa, ekspr2 qiymatidan qat'i nazar, butun iboraning qiymati ham noto'g'ri bo'ladi, hatto hisoblab bo'lmaydi. Ikkinchi iborada, expr1 haqiqiy bo'lsa, expr2 baholanmaydi, chunki expr2-ga qaramasdan butun iboraning qiymati to'g'ri bo'ladi.
Hisoblashning bunday usuli bir va bir iborada bir nechta iboralarni qulay tekshirishga imkon beradi:
while (ptr! = Haqida &&
ptr-> va1ue
ptr-> va1ue> = 0 &&
notFound (ia [ptr-> va1ue]))
{...}
Nol qiymati bo'lgan ko'rsatgich hech qanday ob'ektga ishora qilmaydi, shuning uchun nol ko'rsatkichga a'zo kirish operatsiyasini qo'llash xatoga olib keladi (ptr-> value). Ammo, agar ptr 0 bo'lsa, birinchi bosqichdagi tekshiruv keyingi subpressiyalarni hisoblashni to'xtatadi. Xuddi shunday, ikkinchi va uchinchi bosqichlarda ptr-> qiymati kerakli diapazon uchun tekshiriladi va indeks noto'g'ri bo'lsa, ia massiviga indeks olish operatsiyasi qo'llanilmaydi.
Mantiqiy operatsiya, agar uning yagona operatori noto'g'ri bo'lsa va "aksincha" noto'g'ri bo'lsa, haqiqiy deb aytmaydi. Masalan:
bool found = noto'g'ri;
// element topilmaguncha
// va ptr ob'ektga ishora qiladi (0 emas)
while (! found && ptr) {
topilgan = 1ookup (* ptr);
++ ptr;
}
Subexpression
! topilmadi
o'zgaruvchan yolg'on topilgan bo'lsa, haqiqiy beradi. Bu
topilgan == yolg'on uchun yanada ixcham yozuv
,
xuddi shunday, agar (topilgan)
uzoqroq yozuvga teng
bo'lsa (agar topilgan == haqiqiy)
Taqqoslash operatsiyalaridan foydalanish juda aniq. Shuni yodda tutish kerakki, AND va ORdan farqli o'laroq, bunday iboralarning operandlarini hisoblash tartibi aniqlanmagan. Shunga o'xshash xato bo'lishi mumkin bo'lgan misol:
// Diqqat! Hisoblash tartibi aniqlanmagan!
agar (ia [indeks ++]
// almashtirish elementlari
Dasturchi, avval chap operand baholanadi va ia [0] va ia [1] elementlari taqqoslanadi deb taxmin qildi. Biroq, kompilyator chapdan o'ngga hisoblashlarni kafolatlamaydi, bu holda ia [0] elementni o'zi bilan solishtirish mumkin. Tushunarli va mashinadan mustaqil kodni yozish yaxshiroq:
agar (ia [indeks]
// almashtirish elementlari
++ indeksi;
Mumkin bo'lgan xatoning yana bir misoli. Biz ival, jval va kvallarning uchta qiymati bir-biridan farq qilishiga ishonch hosil qilishni xohladik. Qayerda sog'indik?
// Diqqat! bu 3 ta o'zgaruvchini bir-biri bilan taqqoslash emas
agar (ival! = jva1! = kva1)
// biror narsa qilish ...
0, 1 va 0 qiymatlari bunday ifoda to'g'ri hisoblanishiga olib keladi. Nima uchun? Birinchidan, ival! = Jval tekshiriladi, so'ngra ushbu tekshirish natijasi (true / false - 1/0 ga o'zgartiriladi) kval bilan taqqoslanadi. Biz aniq yozgan bo'lishimiz kerak:
agar (ival! = Jva1 && ival! = Kva1 && jva1! = Kva1)
// biror narsa qilish ...
Noto'g'ri yoki chidab bo'lmas iboralarni toping, tushuntiring. Qanday qilib ularni o'zgartirish mumkin? (E'tibor bering, ushbu misollarda ob'ekt turlari rol o'ynamaydi.)
(A) ptr-> iva1! = 0
(c) ptr! = 0 && * ptr ++
(e) vec [iva1 ++] <= vec [ival];
(b) ival! = jva1 Ma`lumotlarni saqlab qo`yish uchun, tashqi xotiraning nomlangan qismiga fayl deyiladi. Bunday fayllar fizik fayllar deyiladi.
Mantiqiy fayllar. Fizik fayllar bilan ishlash uchun, programmalashtirish tillarida maxsus strukturalashgan, toifalangan fayllar kiritilgan. Bunday fayllar mantiqiy (logicheskiy) fayllar deyiladi. Mantiqiy fayllar, hech qanday fizik xotirani band qilmasdan ma`lumotlarning mantiqiy modelini o`zida saqlaydi.
Fizik va mantiqiy fayllar bir - biri bilan fopen funksiyasi orqali bog'lanadi.
Fayl bir nechta elementdan tashkil topgan bo`lganligi uchun, faqat fayl ko`rsatkichi ko`rsatayotgan elementga murojaat qilish mumkin. Fayldan o'qish yoki yozish mumkin bo'lgan o'rinni ko'rsatuvhi elementga fayl ko'rsatkichi deyiladi. Fayldan ma'lumot o'qiganda yoki yozganda fayl ko'rsatkichi avtomat ravishda o'qilgan yoki yozilgan bayt miqdoricha siljiydi. Fayl ko'rsatkichini magnitafon galovkasiga o'xshatish mumkin.
Binar fayl - har xil ob'ektlarni ifodalovchi baytlar ketma - ketligidir. Ob'ektlar faylda qanday ketma - ketlikda joylashganini programmaning o'zi aniqlashi lozim. Fayllar bilan ishlovchi funksiyalardan foydalanish uchun sarlavha faylini
programmaga qo'shish kerak bo'ladi.
Fayldan ma'lumotlarni o'qish yoki yozish uchun ochish fopen funksiyasi orqali amalga oshiriladi.
FILE * fopen ( const char * filename, const char * mode );
filename - o'zgaruvchisi char toifasidagi satr bo'lib, faylning to'liq nomini ko'rsatishi lozim
(filename = "D:\c++\misol.txt"). Agar faylning faqat nomi ko'rsatilgan bo'lsa, fayl joriy katalogdan qidiriladi (filename = "misol.txt").
mode - o'zgaruvchisi ham char toifasidagi satr bo'lib, faylni qaysi xolatda ochish lozimligini bildiradi. mode qiymati faylning ochilish xolati faylni yozish uchun ochish. falename o'zgaruvchisida ko'rsatilgan fayl hosil qilinadi va unga ma'lumot yozish mumkin"w" bo'ladi. Agar fayl oldindan bor bo'lsa (ya'ni oldin hosil qilingan bo'lsa), faylning ma'lumotlari o'chiriladi va yangi bo'sh fayl faqat yozish uchun ochiq holda bo'ladi. Fayl o'qish uchun ochiladi. Agar fayl oldindan mavjud bo'lmasa,"r" xatolik sodir bo'ladi. Ya'ni ochilishi lozim bo'lgan fayl oldindan hosil qilingan bo'lishi shart.
Faylga yangi ma'lumotlar qo'shish - kiritish uchun ochiladi."a"Yangi kiritilgan ma'lumotlar fayl oxiriga qo'shiladi. Agar fayl
oldindan mavjud bo'lmasa, yangi fayl hosil qilinadi. Yozish va o'qish uchun faylni ochish. Agar fayl oldindan bor bo'lsa (ya'ni oldin hosil qilingan bo'lsa), faylning ma'lumotlari "w+"o'chiriladi va yangi bo'sh fayl yozish va o'qish uchun ochiqholda bo'ladi. "r+"Oldindan mavjud bo'lgan faylni o'qish va yozish uchun ochish. Fayl ma'lumotlarni o'qish va yangi ma'lumot qo'shish uchun "a+" ochiladi. fseek, rewind faylni ochishda xatolik sodir bo'lsa, fopen funksiyasi NULL qiymat qaytaradi.
Ochilgan faylni yopish uchun fclose funksiyasi ishlatiladi.
int fclose ( FILE * stream );
Faylni yopishda xato sodir bo'lmasa, fclose funksiyasi nol qiymat qaytaradi. Xato sodir bo'lsa, EOF - fayl oxiri qaytariladi.
Faylga ma'lumot yozish va o'qish size_t fread ( void * ptr, size_t size, size_t n, FILE * stream ); fread funksiyasi, fayldan ptr ko'rsatkichi adresiga size xajmdagi ma'lumotdan n tani o'qishni amalga oshiradi. Agar o'qish muvoffaqiyatli amalga oshsa fread funksiyasi o'qilgan bloklar soni n ni qaytaradi. Aksholda nol qaytariladi size_t fwrite ( const void * ptr, size_t size, size_t n, FILE * stream ); fwrite funksiyasi, faylga ptr ko'rsatkichi adresidan boshlab size xajmdagi ma'lumotdan n tani yozishni amalga oshiradi.
Misol 1. fread va fwrite funksiyalarining qo'llanilishi
#include
#include
int main()
{
int n = 5;
double d = 10.77;
char s[20] = "tamird.uz";
FILE *f;
// binar faylni yozish uchun ochamiz
f = fopen("misol.txt", "wb");
fwrite(&n, sizeof(int), 1, f); // n sonini faylga yozish
fwrite(&d, sizeof(double), 1, f); // d sonini faylga yozish
// satrni faylga yozish
fwrite(s, sizeof(char), strlen(s) + 1, f);
fclose(f); // faylni yopish
n = 0; d = 0;
// binar faylni o'qish uchun ochamiz
f = fopen("misol.txt", "rb");
fread(&n, sizeof(int), 1, f); // n sonini fayldan o'qish
fread(&d, sizeof(double), 1, f); // d sonini fayldan o'qish
// satrni fayldan o'qish
fread(s, sizeof(char), strlen(s) + 1, f);
fclose(f); // faylni yopish
cout << n << endl;
cout << d << endl;
cout << s << endl;
system (“pause”);
return 0;
}
yuqoridagi misolda satrni yozish va o'qish uchun quyidagicha kod ishlatildi:
fwrite(s, sizeof(char), strlen(s) + 1, f);
fread (s, sizeof(char), strlen(s) + 1, f);
Buning kamchiligi s satridagi har bir belgi alohida - alohida faylga yozildi va o'qildi.
Bu masalani quyidagicha hal qilish mumkin edi:
fwrite(s, sizeof(s), 1, f);
fread (s, sizeof(s), 1, f);
Lekin bu usulning ham kamchiligi bor. Ya'ni s satri belgilar i soni massiv o'lchamidan
kam bo'lgan holda, keraksiz ma'lumotlarni saqlash va o'qish sodir bo'ladi.
Fayl ko'rsatkichi bilan ishlovchi funksiyalar
Fayldan ma'lumot o'qiganda yoki yozganda fayl ko'rsatkichi avtomat ravishda o'qilgan yoki yozilgan bayt miqdoricha siljiydi. Fayl ko'rsatkichining kelgan joyini aniqlash uchun ftell funksiyasi ishlariladi.
long int ftell ( FILE * stream );
Fayl ko'rsatkichini siljit ish uchun fseek funksiyasi ishlatiladi.
int fseek ( FILE * stream, long int offset, int whence);
Bu funksiya offset da ko'ratilgan bayt miqdoricha siljishni amalga oshiradi. whence o'zgaruvchisi quyidagi qiymatlarni qabul qilishi mumkin:
O'zgarmas whence Izoh
SEEK_SET 0 Fayl boshiga nisbatan siljitish fayl ko'rsatkichining joriy SEEK_CUR 1 xolatiga nisbatan siljitish SEEK_END 2 Fayl oxiriga nisbatan siljit ish Agar whence = 1 bo'lsa (SEEK_CUR), offset musbat (o'ngga siljish) yoki manfiy (chapga siljish) bo'lishi mumkin. Fayl ko'rsatkichini faylning boshiga o'rnatish uchun rewind funksiyasi ishlatiladi.
void rewind ( FILE * stream );
Bu amalni fayl ko'rsatkichini siljit ish orqali ham amalga oshirish mumkin.
fseek (f, 0, SEEK_SET);
Agar faylda faqat butun sonlar yozilgan bo'lsa, uning k - elementiga murojaat quyidagicha bo'ladi.
fseek (f, sizeof(int) * (k - 1), SEEK_SET);
fread (&n, sizeof(int), 1, f);
Fayl oxirini aniqlash uchun feof funksiyasi ishlatiladi.
int feof ( FILE * stream );
feof funksiyasi fayl ko'rsatkichi fayl oxirida bo'lsa, noldan farqli qiymat qaytaradi.
Boshqa hollarda nol qaytaradi.
Misol 2. n natural soni berilgan. Elementlari n ta butun sondan iborat bo`lgan faylni hosil qiluvchi va ekranga chiqaruvchi programma tuzilsin.
#include
#include
int main()
{
int n, k;
FILE *f;
f = fopen("binar", "wb+");
// binar faylni yozish va o'qish uchun ochish
if (f == NULL)
cout << "Faylni hosil qilishda xato bo'ldi";
return 1;
cout << "n="; cin >> n;
for (int i = 0; i < n; i++)
cin >> k;
fwrite(&k, sizeof(k), 1, f);
// fayl ko'rsatkichini fayl boshiga qo'yish
rewind(f);
while (fread(&k, sizeof(k), 1, f))
//fayl boshidan fayl ko'rsatkichi turgan o'ringacha bo'lgan baytlar
int bayt = ftell(f);
cout << k <<" ftell(f)=" << bayt << endl
fclose(f);
system (“pause”);
return 0;
Misol 3. n natural soni berilgan. Elementlari n ta butun sondan iborat bo`lgan faylni hosil qiluvchi va juft elementlar ini 2 marta orttiruvchi programma tuzilsin.
#include
#include
int main()
int n, k;
FILE *f;
// binar faylni yozish va o'qish uchun ochish
f = fopen("binar", "wb+");
if (f == NULL)
cout << "Faylni hosil qilishda xato bo'ldi";
return 1;
cout << "n="; cin >> n;
for (int i = 0; i < n; i++)
cin >> k;
fwrite(&k, sizeof(k), 1, f);
// fayl ko'rsatkichini fayl boshiga qo'yish
rewind(f);
while (!feof(f)) // fayl oxiri uchramasa bajar
fread(&k, sizeof(k), 1, f);
if (k % 2 == 0 )
k *= 2;
// fayl ko'rsatkichini sizeof(int) bayt chapga surish
fseek(f, -sizeof(int), SEEK_CUR);
fwrite(&k, sizeof(int), 1, f);
// fayl ko'rsatkichini o'rnatish
fseek(f, ftell(f), SEEK_SET);
cout << "fayl elementlari\n";
rewind(f);
while (fread(&k, sizeof(k), 1, f))
cout << k << endl;
fclose(f);
return 0;
3 - misolni quyidagicha yechish ham mumkin.
#include
#include
using namespace std;
int main()
int n, k;
FILE *f;
f = fopen("binar", "wb+");
cout << "n="; cin >> n;
for (int i = 0; i < n; i++)
cin >> k;
fwrite(&k, sizeof(k), 1, f);
// fayl ko'rsatkichini fayl boshiga qo'yish
rewind(f);
while (!feof(f))
// fayl ko'rsatkichi o'rnini eslab qolish
int pos = ftell(f);
fread(&k, sizeof(k), 1, f);
if (k % 2 == 0 )
k *= 2;
// fayl ko'rsatkichini oldingi xolatiga o'rnatish
fseek(f, pos, SEEK_SET);
fwrite(&k, sizeof(int), 1, f);
// fayl ko'rsatkichi o'rnini sizeof(int) ga surish
pos += sizeof(int);
fseek(f, pos, SEEK_SET);
cout << "fayl elementlari\n";
rewind(f);
// fayl elementlarini chiqarish
while (fread(&k, sizeof(k), 1, f))
cout << k << endl;
fclose(f);
system (“pause”);
return 0;
Xulosa
C ++ tili kompilyatorga buni eng maqbul usulda bajarish uchun taqqoslash operatsiyalarini hisoblash tartibini buyurmaydi. Sizningcha, bu holda ifoda chapdan o'ngga qarab baholanishi bilan bog'liq bo'lgan xatolardan qochish uchun samaradorlikni yo'qotish kerak deb o'ylaysizmi?
Do'stlaringiz bilan baham: |
