2-dars: O'zgaruvchilar va ma'lumot turlari

Dars haqida

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

1. O'zgaruvchi nima?

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

Scratch'da:

set [score] to 0

C'da:

int score = 0;

Bir xil g'oya, boshqa sintaksis.

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)

4. 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 int katta = 1000000000;     // 4 yoki 8 byte
long long int juda_katta = 9999999999LL;  // 8 byte
unsigned int faqat_musbat = 50;  // 4 byte, 0 dan 4,294,967,295 gacha

5. float va double — kasr raqamlar

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

float pi = 3.14;
float harorat = -5.5;
float foiz = 0.25;

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.

6. 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)

Bu — keyingi darsda batafsil.

7. printf bilan o'zgaruvchilarni chiqarish

#include <stdio.h>

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

%d — int uchun format specifier (placeholder).

Format specifiers

Belgi	Tur
`%d`	int
`%i`	int (xuddi `%d`)
`%f`	float
`%lf`	double
`%c`	char
`%s`	string
`%u`	unsigned int
`%ld`	long int
`%lld`	long long
`%x`	hex (kichik)
`%X`	hex (katta)
`%o`	octal
`%e`	scientific
`%%`	foiz belgisi (%)

8. Bir nechta o'zgaruvchi printf

#include <stdio.h>

int main(void) {
    char ism[] = "Akmal";
    int yosh = 22;
    float boy = 1.75;
    
    printf("Ism: %s\n", ism);
    printf("Yosh: %d\n", yosh);
    printf("Bo'y: %.2f m\n", boy);
    
    return 0;
}

Natija:

Ism: Akmal
Yosh: 22
Bo'y: 1.75 m

9. Aniqlik (precision)

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

Format	Tushuntirish
`%f`	Standart (6 o'nli kasr)
`%.2f`	2 o'nli kasr
`%.0f`	Butun ko'rinish
`%10.2f`	10 belgi, 2 o'nli (bo'sh joy bilan)
`%-10.2f`	Chap tomonga tekislash

10. O'zgaruvchini o'zgartirish

int yosh = 25;
printf("Yosh: %d\n", yosh);  // 25

yosh = 26;                    // qayta belgilash
printf("Yangi yosh: %d\n", yosh);  // 26

yosh = yosh + 1;              // 1 ga oshirish
printf("Yana: %d\n", yosh);   // 27

11. Konstanta — o'zgarmaydigan

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;

12. O'zgaruvchi nomlash qoidalari

Qonuniy

int yosh;
int yosh_2;
int yoshKarimov;
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
int yosh.1;       // nuqta yo'q

Reserved keywords (kalit so'zlar)

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

Yaxshi nomlash

// Yomon
int x = 25;
int yu = 1990;
int n;

// Yaxshi
int yosh = 25;
int tugilgan_yil = 1990;
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.

13. Initialize — boshlang'ich qiymat

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.

14. Bir nechta o'zgaruvchi e'lon qilish

// Variant 1
int a = 1;
int b = 2;
int c = 3;

// Variant 2 (bir qatorda)
int a = 1, b = 2, c = 3;

// Variant 3 (bir tur, alohida qiymatlar)
int x, y, z;
x = 10;
y = 20;
z = 30;

15. To'liq misol

#include <stdio.h>

int main(void) {
    // O'zgaruvchilar
    int yosh = 22;
    float boy = 1.75;
    char jins = 'M';
    double og_irlik = 70.5;
    
    // Konstanta
    const double PI = 3.14159;
    
    // BMI hisoblash
    double bmi = og_irlik / (boy * boy);
    
    // Chiqarish
    printf("=== Shaxsiy ma'lumot ===\n");
    printf("Yosh: %d\n", yosh);
    printf("Bo'y: %.2f m\n", boy);
    printf("Og'irlik: %.1f kg\n", og_irlik);
    printf("Jinsi: %c\n", jins);
    printf("BMI: %.2f\n", bmi);
    printf("PI qiymati: %.5f\n", PI);
    
    return 0;
}

Natija:

=== Shaxsiy ma'lumot ===
Yosh: 22
Bo'y: 1.75 m
Og'irlik: 70.5 kg
Jinsi: M
BMI: 23.02
PI qiymati: 3.14159

16. 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)
printf("%.2f\n", 5.0 / 2);      // 2.50

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

17. Hajm — sizeof

#include <stdio.h>

int main(void) {
    printf("int hajmi: %zu byte\n", sizeof(int));
    printf("float hajmi: %zu byte\n", sizeof(float));
    printf("double hajmi: %zu byte\n", sizeof(double));
    printf("char hajmi: %zu byte\n", sizeof(char));
    return 0;
}

Tipik natija:

int hajmi: 4 byte
float hajmi: 4 byte
double hajmi: 8 byte
char hajmi: 1 byte

%zu — size_t turi uchun format specifier.

Darsdagi topshiriqlar

Topshiriq 1 — Shaxsiy ma'lumot

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

#include <stdio.h>

int main(void) {
    char ism[] = "Akmal";
    int yosh = 22;
    float boy = 1.75;
    double og_irlik = 70.5;
    char jins = 'M';
    
    printf("Ism: %s\n", ism);
    printf("Yosh: %d yosh\n", yosh);
    // ... qolganlari
    
    return 0;
}

Kompilyatsiya va ishga tushiring.

Topshiriq 2 — Kalkulyator (oddiy)

kalkulyator.c:

#include <stdio.h>

int main(void) {
    int a = 10;
    int b = 3;
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    printf("a + b = %d\n", a + b);
    printf("a - b = %d\n", a - b);
    printf("a * b = %d\n", a * b);
    printf("a / b = %d (integer)\n", a / b);
    printf("a %% b = %d (qoldiq)\n", a % b);
    printf("(float) a / b = %.2f\n", (float)a / b);
    
    return 0;
}

%% — printf'da foiz belgisi chiqarish uchun.

Natijalarni Drive'ga screenshot.

Topshiriq 3 — Doira hisobi

Doira radiusi, perimetri va yuzasi.

#include <stdio.h>

int main(void) {
    const double PI = 3.14159;
    double radius = 5.0;
    
    double perimeter = 2 * PI * radius;
    double area = PI * radius * radius;
    
    printf("Radius: %.2f\n", radius);
    printf("Perimeter: %.2f\n", perimeter);
    printf("Area: %.2f\n", area);
    
    return 0;
}

Saqlang va sinab ko'ring.

Topshiriq 4 — Format specifiers

formatlar.c:

#include <stdio.h>

int main(void) {
    int x = 42;
    float y = 3.14;
    double z = 2.71828;
    char c = 'A';
    
    printf("Decimal: %d\n", x);
    printf("Hex: %x\n", x);
    printf("Octal: %o\n", x);
    printf("Float: %f\n", y);
    printf("Float 2 decimal: %.2f\n", y);
    printf("Double: %lf\n", z);
    printf("Scientific: %e\n", z);
    printf("Char: %c\n", c);
    printf("ASCII raqam: %d\n", c);
    
    return 0;
}

Har formatdan keyin natijaning farqi nima?

Topshiriq 5 — 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 6 — BMI calculator

bmi.c — Body Mass Index (vazn indeksi):

BMI formula: BMI = vazn / (bo'y * bo'y)

vazn — kg
bo'y — m

#include <stdio.h>

int main(void) {
    double vazn = 70.5;
    double boy = 1.75;
    
    double bmi = vazn / (boy * boy);
    
    printf("Vazn: %.1f kg\n", vazn);
    printf("Bo'y: %.2f m\n", boy);
    printf("BMI: %.2f\n", bmi);
    
    return 0;
}

Sinab ko'ring. BMI 18.5–24.9 — normal.

Topshiriq 7 — Sizeof

hajm.c:

#include <stdio.h>

int main(void) {
    printf("Hajmlar (byte):\n");
    printf("char: %zu\n", sizeof(char));
    printf("short: %zu\n", sizeof(short));
    printf("int: %zu\n", sizeof(int));
    printf("long: %zu\n", sizeof(long));
    printf("long long: %zu\n", sizeof(long long));
    printf("float: %zu\n", sizeof(float));
    printf("double: %zu\n", sizeof(double));
    printf("long double: %zu\n", sizeof(long double));
    return 0;
}

Natijani daftarga yozing.

Boshqa kompyuterda ham sinang — natija farq qiladimi?

Topshiriq 8 — GitHub'ga

Hamma .c fayllarni:

bash

$ cd ~/c-darslari
$ mkdir 4-oy-dars-2
$ # fayllarni shu papkaga ko'chiring
$ git add .
$ git commit -m "feat: dars 2 - variables and types"
$ 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.)

Keyingi dars

3-dars: Operatorlar →

2-dars: O'zgaruvchilar va ma'lumot turlari ​

1. O'zgaruvchi nima? ​

2. O'zgaruvchi e'lon qilish ​

3. Ma'lumot turlari (Data Types) ​

4. int — butun raqam ​

Variantlar ​

5. float va double — kasr raqamlar ​

6. char — bitta harf ​

7. printf bilan o'zgaruvchilarni chiqarish ​

Format specifiers ​

8. Bir nechta o'zgaruvchi printf ​

9. Aniqlik (precision) ​

10. O'zgaruvchini o'zgartirish ​

11. Konstanta — o'zgarmaydigan ​

12. O'zgaruvchi nomlash qoidalari ​

Qonuniy ​

Qonuniy emas ​

Reserved keywords (kalit so'zlar) ​

Yaxshi nomlash ​

13. Initialize — boshlang'ich qiymat ​

14. Bir nechta o'zgaruvchi e'lon qilish ​

15. To'liq misol ​

16. Tur konversiyasi (Type casting) ​

Avtomatik konversiya ​

Manual cast ​

Bo'lish va cast ​

17. Hajm — sizeof ​

Darsdagi topshiriqlar ​

Asosiy tushunchalar (lug'at) ​

Keyingi dars ​