8-dars: O'zgaruvchilar, turlar va operatorlar

Dars haqida

Davomiyligi: 90 daqiqa Maqsad: Talaba C tilida o'zgaruvchilar e'lon qilishi, asosiy ma'lumot turlarini (int, float, char, double) bilishi hamda matematik, taqqoslash va mantiqiy operatorlardan to'g'ri foydalanishi kerak.

1. O'zgaruvchi nima?

O'zgaruvchi (variable) — qiymat saqlash uchun xotira hujayrasi. Nom va qiymat bor.

3-darsda pseudocode'da shunday yozgan edik:

SET score = 0

C'da:

int score = 0;

Bir xil g'oya — endi haqiqiy dasturlash tilida.

2. O'zgaruvchi e'lon qilish

Format:

tur nom = qiymat;

Misollar:

int yosh = 22;
float pi = 3.14;
char harf = 'A';
double dollar_kursi = 12500.50;

C qoidasi

C'da avval tur belgilanadi, keyin nom. Bu statically typed deyiladi.

3. Ma'lumot turlari (Data Types)

int — butun raqam

int — eng keng tarqalgan tur.

int yosh = 25;
int ball = -10;
int yil = 2026;

Hajmi: odatda 4 byte (32 bit). Diapazon: -2,147,483,648 dan +2,147,483,647 gacha.

Variantlar:

short int kichik = 100;          // 2 byte
long long int juda_katta = 9999999999LL;  // 8 byte
unsigned int faqat_musbat = 50;  // 4 byte, 0 dan 4,294,967,295 gacha

float va double — kasr raqamlar

float — kasr raqam (single precision, 4 byte).

float pi = 3.14;
float harorat = -5.5;

double — yuqori aniqlik (double precision, 8 byte).

double aniq_pi = 3.14159265358979;
double dollar_kursi = 12500.5634;

Qachon float, qachon double?

float — kichik aniqlik yetadi (grafika, oddiy hisob)
double — yuqori aniqlik (ilmiy, moliya)

Sukut bo'yicha double ishlating — aniqlik muhim.

char — bitta harf

char — bitta belgi (1 byte).

char harf = 'A';
char raqam = '7';
char belgi = '$';

Qo'shtirnoq

Bitta harf — 'A' (apostroflar) Matn (string) — "Akmal" (qo'shtirnoq)

String'lar bilan keyinroq batafsil ishlaymiz.

4. printf va format specifiers

#include <stdio.h>

int main(void) {
    int yosh = 25;
    printf("Mening yoshim: %d\n", yosh);
    return 0;
}

%d — int uchun format specifier (placeholder).

Belgi	Tur
`%d`	int
`%f`	float
`%lf`	double
`%c`	char
`%s`	string
`%x`	hex
`%o`	octal
`%e`	scientific
`%%`	foiz belgisi (%)

Bir nechta o'zgaruvchi

char ism[] = "Akmal";
int yosh = 22;
float boy = 1.75;

printf("Ism: %s\n", ism);      // Ism: Akmal
printf("Yosh: %d\n", yosh);    // Yosh: 22
printf("Bo'y: %.2f m\n", boy); // Bo'y: 1.75 m

Aniqlik (precision)

float pi = 3.14159265;
printf("%f\n", pi);       // 3.141593 (standart — 6 o'nli kasr)
printf("%.2f\n", pi);     // 3.14 (2 o'nli kasr)
printf("%.4f\n", pi);     // 3.1416
printf("%10.2f\n", pi);   // "      3.14" (10 belgi bo'sh joy bilan)

5. O'zgaruvchini o'zgartirish va const

int yosh = 25;
yosh = 26;                    // qayta belgilash
yosh = yosh + 1;              // 1 ga oshirish → 27

const kalit so'zi — o'zgaruvchini o'zgarmas qiladi.

const float PI = 3.14159;
PI = 4.0;  // XATO! Konstantani o'zgartirib bo'lmaydi

Konventsiya — KATTA HARF bilan yoziladi:

const int MAX_TALABA = 30;
const double LIGHT_SPEED = 299792458.0;

6. O'zgaruvchi nomlash qoidalari

Qonuniy

int yosh;
int yosh_2;
int _maxlife;
int xizmat3;

Qonuniy emas

int 2yosh;        // raqam bilan boshlanmaydi
int yosh-1;       // tire ishlatib bo'lmaydi
int int;          // kalit so'z
int my var;       // bo'shliq yo'q

Reserved keywords (kalit so'zlar)

int, float, char, if, else, for, while, return, void, const va boshqalar — o'zgaruvchi nomi sifatida ishlatib bo'lmaydi.

Yaxshi nomlash

// Yomon
int x = 25;
int n;

// Yaxshi
int yosh = 25;
int talabalar_soni;

Naming conventions

snake_case — tugilgan_yil (C va Python uchun standart)
camelCase — tugilganYil (Java, JavaScript)
PascalCase — TugilganYil (sinflar uchun)

C'da odatda snake_case ishlatiladi.

7. Initialize va bir nechta e'lon qilish

int yosh = 25;          // initialize bilan
int ball;                // initialize'siz
ball = 100;              // keyin belgilash

Initialize qilmaslik

int x;
printf("%d\n", x);  // ← noma'lum qiymat (garbage value)

Boshlang'ich qiymat bermasangiz — xotirada qolgan "axlat" qiymat chiqadi.

Doim initialize qiling.

Bir nechta o'zgaruvchi bir qatorda:

int a = 1, b = 2, c = 3;

8. Tur konversiyasi (Type casting)

Avtomatik konversiya

int a = 5;
double b = a;       // int → double avtomatik
// b = 5.0

Manual cast

double pi = 3.14;
int butun = (int)pi;   // 3 (kasr qism yo'q)

Bo'lish va cast

int a = 5, b = 2;

printf("%d\n", a / b);          // 2 (integer bo'lish)
printf("%f\n", (float)a / b);   // 2.500000 (float bo'lish)

Integer division

int natija = 5 / 2;  // 2 (NOT 2.5!)

C'da ikkala raqam int bo'lsa — natija ham int (kasr tashlanadi).

To'g'ri yo'l:

float natija = 5.0 / 2;       // 2.5
// yoki
float natija = (float)5 / 2;  // 2.5

9. Hajm — sizeof

printf("%zu\n", sizeof(int));     // 4
printf("%zu\n", sizeof(float));   // 4
printf("%zu\n", sizeof(double));  // 8
printf("%zu\n", sizeof(char));    // 1

%zu — size_t turi uchun format specifier. sizeof — funksiya emas, operator.

10. Operator nima?

Operator — qiymatlar ustida amal bajaruvchi belgi.

int natija = 5 + 3;  // + — operator

Turlari:

11. Arithmetic — matematik operatorlar

Operator	Vazifa	Misol
`+`	Qo'shish	`5 + 3 = 8`
`-`	Ayirish	`5 - 3 = 2`
`*`	Ko'paytirish	`5 * 3 = 15`
`/`	Bo'lish	`10 / 2 = 5`
`%`	Modulo (qoldiq)	`10 % 3 = 1`

int a = 10, b = 3;
printf("%d\n", a + b);  // 13
printf("%d\n", a - b);  // 7
printf("%d\n", a * b);  // 30
printf("%d\n", a / b);  // 3 (integer division)
printf("%d\n", a % b);  // 1 (qoldiq)

Modulo (%) foydasi

Toq/juft tekshirish:

int x = 10;
if (x % 2 == 0) {
    printf("Juft\n");
} else {
    printf("Toq\n");
}

12. Assignment — belgilash operatorlari

Operator	Misol	Ma'no
`=`	`x = 5`	x = 5
`+=`	`x += 3`	x = x + 3
`-=`	`x -= 3`	x = x - 3
`*=`	`x *= 2`	x = x * 2
`/=`	`x /= 2`	x = x / 2
`%=`	`x %= 3`	x = x % 3

int x = 10;

x += 5;      // x = 15
x *= 2;      // x = 30
x %= 4;      // x = 2

13. Increment va Decrement

int x = 5;

x++;     // x = 6 (postfix)
++x;     // x = 7 (prefix)

x--;     // x = 6
--x;     // x = 5

Prefix vs Postfix farq

int a = 5;
int b = a++;      // b = 5, a = 6 (postfix: avval ber, keyin oshir)

int c = 5;
int d = ++c;      // d = 6, c = 6 (prefix: avval oshir, keyin ber)

Tavsiya

Boshlovchi uchun postfix ishlating (x++). Aralashtirib ishlatish — chigallik.

14. Comparison — taqqoslash operatorlari

Natija — 0 (false) yoki 1 (true).

Operator	Vazifa	Misol
`==`	Teng	`5 == 5` → 1
`!=`	Teng emas	`5 != 3` → 1
`>`	Katta	`5 > 3` → 1
`<`	Kichik	`5 < 3` → 0
`>=`	Katta yoki teng	`5 >= 5` → 1
`<=`	Kichik yoki teng	`5 <= 3` → 0

= vs ==

= — belgilash (assignment) == — taqqoslash (comparison)

Eng keng tarqalgan xato:

if (x = 5) { ... }   // XATO! x ni 5 ga belgilaydi va doim true
if (x == 5) { ... }  // To'g'ri — taqqoslash

15. Logical — mantiqiy operatorlar

Operator	Vazifa	Misol
`&&`	AND (va)	`(5 > 3) && (10 < 20)` → 1
`\|\|`	OR (yoki)	`(5 > 3) \|\| (10 > 20)` → 1
`!`	NOT (emas)	`!(5 > 3)` → 0

3-darsdagi AND/OR/NOT — endi C sintaksisida:

int yosh = 25;

// Yosh 18-60 oralig'idami?
if (yosh >= 18 && yosh <= 60) {
    printf("Ishlash yoshi\n");
}

// Shahar kodi 'T' (Toshkent) yoki 'S' (Samarqand) bo'lsa
char shahar_kodi = 'T';
if (shahar_kodi == 'T' || shahar_kodi == 'S') {
    // ...
}
// Diqqat: butun matnni (string) == bilan taqqoslab BO'LMAYDI —
// buning uchun strcmp() kerak (keyinroq o'rganamiz)

Truth table

A	B	A && B	A \|\| B	!A
0	0	0	0	1
0	1	0	1	1
1	0	0	1	0
1	1	1	1	0

Short-circuit evaluation

C lazy — natija oldindan ma'lum bo'lsa, qolganini hisoblamasdan to'xtaydi.

if (0 && very_slow_function()) {
    // very_slow_function() umuman chaqirilmaydi (chap tomon 0)
}

16. Bitwise operatorlar (qisqacha)

Bitwise — bit darajasida amallar.

Operator	Vazifa
`&`	Bitwise AND
`\|`	Bitwise OR
`^`	Bitwise XOR
`~`	Bitwise NOT
`<<`	Left shift
`>>`	Right shift

Bitwise foydasi

Tezkor amallar, bit flag'lar, hardware dasturlash. Boshlovchi uchun — kelajakda kerak.

17. Conditional (Ternary) operator

Qisqa if-else.

sharti ? agar_rost : agar_yolgon

Misol:

int yosh = 25;
char *natija = (yosh >= 18) ? "Kattalar" : "Bola";
printf("%s\n", natija);  // "Kattalar"

Ternary — if-else'ni bir qatorda yozish uchun foydali.

18. Operatorlar tartibi (Precedence)

C'da har operator prioritetga ega.

int x = 2 + 3 * 4;     // 14 (NOT 20)

Sabab: * +'dan oldin.

Asosiy tartib (yuqori → past)

() — qavslar
++, -- (postfix)
++, -- (prefix), !, ~, (type), sizeof
*, /, %
+, -
<, <=, >, >=
==, !=
&&
||
?:
=, +=, -= va h.k.

Qavslar bilan aniq qiling

Tartibni eslab qolish o'rniga — qavslar ishlating:

// Tushunarsiz
int x = a + b * c - d / e;

// Tushunarli
int x = a + (b * c) - (d / e);

19. To'liq misol

#include <stdio.h>

int main(void) {
    int a = 10, b = 3;
    
    // Arithmetic
    int sum = a + b;
    int quot = a / b;
    int rem = a % b;
    
    // Comparison
    int gt = (a > b);
    
    // Logical
    int both = (a > 0) && (b > 0);
    
    // Ternary
    int max = (a > b) ? a : b;
    
    // Compound assignment
    a += 5;        // a = 15
    b *= 2;        // b = 6
    
    printf("Sum: %d\n", sum);
    printf("Quot: %d, Rem: %d\n", quot, rem);
    printf("a > b? %d\n", gt);
    printf("Both positive? %d\n", both);
    printf("Max: %d\n", max);
    printf("New a: %d, New b: %d\n", a, b);
    
    return 0;
}

20. Common pitfalls (keng tarqalgan xatolar)

Yuqorida ko'rgan uchta klassik xatoni yodda tuting: = vs ==, integer division (5 / 2 = 2), operator priority (2 + 3 * 4 = 14). Yana ikkitasi:

Modulo va negative

printf("%d\n", -7 % 3);  // -1 (C99+)
printf("%d\n", 7 % -3);  // 1

C'da modulo natijasi — birinchi argument bilan bir xil belgi.

Overflow

int max = 2147483647;  // INT_MAX
max = max + 1;          // overflow! → -2147483648

int chegarasidan oshib ketsa — noto'g'ri natija.

Darsdagi topshiriqlar

Topshiriq 1 — Shaxsiy ma'lumot

shaxsiy.c faylida o'zingiz haqida turli turdagi o'zgaruvchilar yarating va chiqaring:

char ism[] — ismingiz (%s)
int yosh — yoshingiz (%d)
float boy — bo'yingiz (%.2f)
double vazn — vazningiz
char jins — jinsi, bitta belgi (%c)

Har birini mos format bilan chiqaring. Kompilyatsiya va ishga tushiring.

Topshiriq 2 — Doira hisobi

doira.c — berilgan radius bo'yicha doiraning perimetri va yuzasini hisoblab chiqaruvchi dastur yozing.

PI ni const double sifatida e'lon qiling (3.14159)
Perimetr = 2 * PI * r, Yuza = PI * r * r
Natijalarni %.2f bilan chiqaring

Saqlang va sinab ko'ring.

Topshiriq 3 — Tur konversiya

konversiya.c:

#include <stdio.h>

int main(void) {
    int a = 7;
    int b = 2;
    
    int int_natija = a / b;
    float float_natija_1 = a / b;            // ehtiyot!
    float float_natija_2 = (float)a / b;
    float float_natija_3 = a / (float)b;
    
    printf("int / int = %d\n", int_natija);
    printf("float natija 1 (xato): %f\n", float_natija_1);
    printf("float natija 2 (to'g'ri): %f\n", float_natija_2);
    printf("float natija 3 (to'g'ri): %f\n", float_natija_3);
    
    return 0;
}

Sinab ko'ring. Nima uchun natijalar farqli? Daftarga tushuntiring.

Topshiriq 4 — Toq/juft tekshirish

toq-juft.c — berilgan butun son juft yoki toq ekanini aniqlab chop etuvchi dastur yozing. % (qoldiq) operatoridan foydalaning.

x qiymatini turli qiymatlarga o'zgartirib sinang: 7, 100, 0, -5, 1.

Topshiriq 5 — Compound assignment

compound.c — bitta score o'zgaruvchisini 100 dan boshlab, ketma-ket compound operatorlar bilan yangilab boring va har qadamdan keyin qiymatini chiqaring:

+= 50, keyin -= 30, keyin *= 2, keyin /= 4, keyin %= 10

Maslahat: printfda foiz belgisini chiqarish uchun %% yoziladi.

Topshiriq 6 — Ternary

ternary.c — ternary operator (? :) yordamida quyidagilarni hisoblang:

ikkita sondan max va min
yoshga qarab kategoriya: 18+ → "Kattalar", aks holda "Bola"
ball bo'yicha zanjirli ternary: 90+ → "A", 75+ → "B", 60+ → "C", aks holda "F"

Har birini chiqaring.

Topshiriq 7 — Tartib

tartib.c:

#include <stdio.h>

int main(void) {
    int a = 2 + 3 * 4;
    int b = (2 + 3) * 4;
    int c = 2 * 3 + 4 * 5;
    int d = 10 - 5 + 3;
    int e = 10 / 2 * 3;
    int f = 2 * 3 + 4 / 2 - 1;
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    printf("c = %d\n", c);
    printf("d = %d\n", d);
    printf("e = %d\n", e);
    printf("f = %d\n", f);
    
    return 0;
}

Har birini oldindan o'ylab daftarga yozing. Keyin kompilyatsiya qiling va to'g'rimi tekshiring.

Topshiriq 8 — GitHub'ga

Hamma .c fayllarni push qiling:

bash

$ cd ~/c-darslari
$ mkdir 4-oy-dars-8
$ # fayllarni shu papkaga ko'chiring
$ git add .
$ git commit -m "feat: dars 8 - variables and operators"
$ git push

Asosiy tushunchalar (lug'at)

Termin	Qisqacha izoh
Variable	O'zgaruvchi
Data type	Ma'lumot turi
int	Butun raqam
float / double	Kasr raqam
char	Bitta belgi
const	O'zgarmas
Format specifier	%d, %f, %c va h.k.
Initialize	Boshlang'ich qiymat
Garbage value	Tasodifiy "axlat" qiymat
Type casting	Tur konversiyasi
Integer division	Butun bo'lish
sizeof	Hajmni topish
snake_case	Nomlash uslubi (C standart)
Reserved keyword	Kalit so'z (int, if va h.k.)
Operator	Amal bajaruvchi belgi
Arithmetic	Matematik (+, -, *, /, %)
Modulo (%)	Bo'lish qoldigi
Assignment	Belgilash (=, +=, -=)
Comparison	Taqqoslash (==, !=, >, <)
Logical	Mantiqiy (&&, \|\|, !)
Bitwise	Bit darajasidagi
Increment/Decrement	++ / -- (prefix/postfix)
Ternary	? : qisqa if-else
Precedence	Tartib (qaysi avval)
Short-circuit	Lazy hisob
Overflow	Chegaradan oshib ketish

Keyingi dars

9-dars: Shartlar — if, else, switch →

8-dars: O'zgaruvchilar, turlar va operatorlar ​

1. O'zgaruvchi nima? ​

2. O'zgaruvchi e'lon qilish ​

3. Ma'lumot turlari (Data Types) ​

int — butun raqam ​

float va double — kasr raqamlar ​

char — bitta harf ​

4. printf va format specifiers ​

Bir nechta o'zgaruvchi ​

Aniqlik (precision) ​

5. O'zgaruvchini o'zgartirish va const ​

6. O'zgaruvchi nomlash qoidalari ​

Qonuniy ​

Qonuniy emas ​

Reserved keywords (kalit so'zlar) ​

Yaxshi nomlash ​

7. Initialize va bir nechta e'lon qilish ​

8. Tur konversiyasi (Type casting) ​

Avtomatik konversiya ​

Manual cast ​

Bo'lish va cast ​

9. Hajm — sizeof ​

10. Operator nima? ​

11. Arithmetic — matematik operatorlar ​

Modulo (%) foydasi ​

12. Assignment — belgilash operatorlari ​

13. Increment va Decrement ​

Prefix vs Postfix farq ​

14. Comparison — taqqoslash operatorlari ​

15. Logical — mantiqiy operatorlar ​

Truth table ​

Short-circuit evaluation ​

16. Bitwise operatorlar (qisqacha) ​

17. Conditional (Ternary) operator ​

18. Operatorlar tartibi (Precedence) ​

Asosiy tartib (yuqori → past) ​

19. To'liq misol ​

20. Common pitfalls (keng tarqalgan xatolar) ​

Modulo va negative ​

Overflow ​

Darsdagi topshiriqlar ​

Asosiy tushunchalar (lug'at) ​

Keyingi dars ​