Xotira boshqaruvi asoslari

#include <stdio.h>
#include <stdlib.h>

int global_ozgaruvchi = 42;
int global_nol;
const char *matn = "doimiy satr";

int main(void) {
    int stek_ozgaruvchisi = 7;
    int *uyum = malloc(sizeof(int));

    if (uyum == NULL) {
        return 1;
    }

    /* Manzillarni bir-biri bilan solishtiramiz */
    void *kod = (void *) main;
    void *data = &global_ozgaruvchi;
    void *bss = &global_nol;
    void *stek = &stek_ozgaruvchisi;

    printf("Kod eng pastdami?          %s\n", kod < data ? "ha" : "yo'q");
    printf("Data bss dan pastdami?     %s\n", data < bss ? "ha" : "yo'q");
    printf("Uyum bss dan yuqoridami?   %s\n", (void *) uyum > bss ? "ha" : "yo'q");
    printf("Stek uyumdan yuqoridami?   %s\n", stek > (void *) uyum ? "ha" : "yo'q");

    free(uyum);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char *kichik   = malloc(100);
    char *ikkinchi = malloc(100);
    char *katta    = malloc(200 * 1024 * 1024);   /* 200 MB */

    if (kichik == NULL || ikkinchi == NULL || katta == NULL) {
        return 1;
    }

    long uyum_ichida = ikkinchi - kichik;
    long katta_farq  = katta > kichik ? katta - kichik : kichik - katta;

    printf("Ikki kichik bo'lak orasidagi masofa: %ld bayt\n", uyum_ichida);
    printf("Ular bitta sohadami?            %s\n",
           uyum_ichida < 4096 ? "ha" : "yo'q");
    printf("Katta bo'lak 1 GB dan uzoqdami? %s\n",
           katta_farq > 1024L * 1024 * 1024 ? "ha" : "yo'q");

    free(kichik);
    free(ikkinchi);
    free(katta);

    return 0;
}

#include <stdio.h>
#include <sys/mman.h>
#include <string.h>

int main(void) {
    size_t hajm = 4096;

    int *xotira = mmap(NULL, hajm,
                       PROT_READ | PROT_WRITE,
                       MAP_PRIVATE | MAP_ANONYMOUS,
                       -1, 0);

    if (xotira == MAP_FAILED) {
        printf("mmap muvaffaqiyatsiz\n");
        return 1;
    }

    for (int i = 0; i < 10; i++) {
        xotira[i] = i * i;
    }

    printf("mmap bilan xotira olindi\n");
    printf("Boshlang'ich qiymat nolmi? %s\n", xotira[500] == 0 ? "ha" : "yo'q");
    printf("Yozilgan qiymatlar: %d %d %d\n", xotira[2], xotira[3], xotira[4]);

    munmap(xotira, hajm);
    printf("Xotira qaytarildi\n");

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

int main(void) {
    const char *nom = "sinov_mmap.txt";
    const char *matn = "Salom, xotiraga bog'langan fayl!";

    /* fayl yaratamiz */
    FILE *f = fopen(nom, "w");

    if (f == NULL) {
        return 1;
    }

    fputs(matn, f);
    fclose(f);

    /* faylni ochib, xotiraga bog'laymiz */
    int fd = open(nom, O_RDONLY);

    if (fd < 0) {
        return 1;
    }

    struct stat holat;

    if (fstat(fd, &holat) < 0) {
        close(fd);
        return 1;
    }

    char *xarita = mmap(NULL, (size_t) holat.st_size,
                        PROT_READ, MAP_PRIVATE, fd, 0);

    close(fd);

    if (xarita == MAP_FAILED) {
        printf("mmap muvaffaqiyatsiz\n");
        return 1;
    }

    printf("Fayl hajmi     : %ld bayt\n", (long) holat.st_size);
    printf("Birinchi belgi : %c\n", xarita[0]);
    printf("Mazmuni to'g'rimi? %s\n",
           strncmp(xarita, matn, (size_t) holat.st_size) == 0 ? "ha" : "yo'q");

    munmap(xarita, (size_t) holat.st_size);
    remove(nom);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    void *a = malloc(1);
    void *b = malloc(1);

    if (a == NULL || b == NULL) {
        return 1;
    }

    long farq = (char *) b - (char *) a;

    printf("Ikki marta malloc(1) chaqirildi\n");
    printf("Manzillar orasidagi farq 1 baytdan kattami? %s\n",
           farq > 1 || farq < -1 ? "ha" : "yo'q");
    printf("Farq kamida 16 baytmi? %s\n",
           farq >= 16 || farq <= -16 ? "ha" : "yo'q");

    free(a);
    free(b);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Ataylab siziydigan funksiya */
static void sizadi(void) {
    char *bufer = malloc(1024);

    if (bufer != NULL) {
        strcpy(bufer, "bu xotira hech qachon ozod qilinmaydi");
    }

    /* free(bufer) yo'q */
}

int main(void) {
    printf("Xotira sizishini ko'rsatuvchi dastur\n");

    for (int i = 0; i < 5; i++) {
        sizadi();
    }

    printf("5 marta 1024 bayt sizdi = 5120 bayt\n");
    printf("Buni sanitizer yoki valgrind aniqlaydi\n");

    return 0;
}

gcc -std=c17 -g -fsanitize=address sizish.c -o sizish
./sizish

=================================================================
ERROR: LeakSanitizer: detected memory leaks

Direct leak of 5120 byte(s) in 5 object(s) allocated from:
    #0 0x... in malloc
    #1 0x... in sizadi sizish.c:7
    #2 0x... in main sizish.c:22

SUMMARY: AddressSanitizer: 5120 byte(s) leaked in 5 allocation(s).

ps -o pid,vsz,rss,comm -p $$

    PID    VSZ   RSS COMMAND
   1204  12456  5204 bash

cat /proc/self/status | grep -E "VmSize|VmRSS|VmData|VmStk"

VmSize:       12456 kB
VmRSS:        5204 kB
VmData:        1024 kB
VmStk:         132 kB

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    /* Juda katta so'rov - albatta rad etiladi */
    size_t juda_katta = (size_t) 1024 * 1024 * 1024 * 1024;   /* 1 TB */

    void *xotira = malloc(juda_katta);

    if (xotira == NULL) {
        printf("malloc NULL qaytardi - so'rov rad etildi\n");
        printf("Dastur qulamadi, chunki natija tekshirildi\n");
        return 0;
    }

    printf("Kutilmaganda muvaffaqiyatli bo'ldi\n");
    free(xotira);

    return 0;
}