C'de struct, dinamik bellek ve giriş/çıkış (printf, scanf)

Dönemin son konusu, C’de birden fazla bilgiyi bir arada tutmanın yolu: struct. Bir öğrencinin adı ve notu, bir noktanın x ve y’si, bir listenin düğümü. Bunun yanında programın çalışırken bellek istemesini (malloc) ve kullanıcıyla konuşmasını (printf, scanf) da göreceksin. Soru tipleri değişmiyor: struct ve pointer içeren “What is printed?”, printf biçim soruları, bellek bölgesi soruları.

struct

struct point {
    int x;
    int y;
};

struct point p;
p.x = 7;
p.y = -1;

struct yeni bir tip tanımlar; içindeki değişkenlere üye (member) denir. Üyelere . ile erişilir. Bellekte üyeler art arda durur: LC-3’te struct point iki kelime kaplar, p.x ilk kelimede, p.y ikincide.

Başlatma: struct point p = {3, 4}; (sırayla x = 3, y = 4).

typedef

Her seferinde struct point yazmamak için takma ad verilir:

typedef struct {
    char name[12];
    int score;
} Student;

Student s = {"Ada", 70};

struct’lar değerle kopyalanır

b = a; tüm üyeleri kopyalar. Bir fonksiyona struct geçirmek de kopyalamaktır. Fonksiyon kopyayı değiştirir, aslı değişmez. (Dizilerin tam tersi: dizi geçirince adres geçer.)

void moveBad(struct point p)   { p.x += 10; }   /* kopya */
void moveGood(struct point *p) { p->x += 10; }  /* asıl */

-> operatörü

Bir struct pointer’ı üzerinden üyeye erişmek için (*p).x yazılır. Bu çok sık kullanıldığı için kısaltması var: p->x.

struct point p;
p.x = 7;
p.y = -1;
struct point *pp = &p;
pp->y = pp->x * 2;
printf("(%d, %d)\n", p.x, p.y);

(7, 14)

TUZAK · *p.x. . operatörünün önceliği *’dan yüksektir: *p.x = *(p.x), yani “x üyesini pointer say”. Doğrusu (*p).x ya da p->x.

struct dizileri

Student s[3] = {{"Ada", 70}, {"Can", 85}, {"Ece", 60}};
s[1].score      /* 85 */
s[2].name[0]    /* 'E' */

Struct pointer’ı bir artırınca bir struct ilerler (pointer aritmetiği tipin boyutunu bilir).

Bağlı liste (linked list)

Bir struct, kendi tipinden bir pointer içerebilir. Böylece düğümler birbirine bağlanır:

struct node {
    int val;
    struct node *next;
};

head ──► [10 | •]──► [20 | •]──► [30 | NULL]

Gezinme kalıbı:

for (p = head; p != NULL; p = p->next)
    ... p->val ...

Diziden farkı: eleman eklemek için kaydırma gerekmez, sadece pointer’lar değişir. Ama i’inci elemana doğrudan atlanamaz, baştan yürümek gerekir.

Dinamik bellek: malloc ve free

Programın çalışırken ne kadar bellek isteyeceği baştan bilinmiyorsa heap’ten yer istenir.

#include <stdlib.h>

int *v = malloc(4 * sizeof(int));   /* 4 int'lik yer */
v[0] = 5;                           /* dizi gibi kullan */
free(v);                            /* işin bitince geri ver */

• malloc(n) n byte ayırır, başlangıç adresini döndürür (yer yoksa NULL).
• sizeof(T) bir tipin kaç byte olduğunu verir; elle sayı yazma.
• free edilmeyen bellek, program bitene kadar kaybolur (memory leak).

Liste kurmak:

struct node *head = NULL;
int i;
for (i = 1; i <= 3; i++) {
    struct node *n = malloc(sizeof(struct node));
    n->val = i * 10;
    n->next = head;     /* başa ekle */
    head = n;
}

Liste: 30 → 20 → 10. Her yeni düğüm başa eklendiği için sıra ters.

Gezinip basınca:

struct node *p;
for (p = head; p != NULL; p = p->next)
    printf("%d ", p->val);

30 20 10

Adım adım ne oldu:

i=1: n1 = {10, NULL}   head → n1
i=2: n2 = {20, n1}     head → n2 → n1
i=3: n3 = {30, n2}     head → n3 → n2 → n1

Listenin tamamını silmek için de aynı kalıp: while (head) { t = head; head = head->next; free(t); }. Önce next’i kaydetmeden free(head) yaparsan listenin geri kalanına ulaşamazsın.

struct’ın LC-3 bellek düzeni

LC-3’te int bir kelime olduğu için struct point iki kelimedir. struct point pts[3]; x4000’de başlıyorsa:

x4000  pts[0].x      x4001  pts[0].y
x4002  pts[1].x      x4003  pts[1].y
x4004  pts[2].x      x4005  pts[2].y

Genel formül: &pts[i].y = taban + 2i + 1. Derleyici q->y için q’daki adrese 1 ekleyip LDR yapar: LDR R1, R0, #1. Üyelerin struct başından uzaklığı (offset) sabit olduğu için LDR/STR’nin base+offset kipi tam bu iş için uygundur.

Bellek bölgeleri

LC-3’te yığın yüksek adreslerden aşağı, heap global bölgenin üstünden yukarı büyür.

TUZAK · yerel değişkenin adresini döndürmek. int *f(void) { int x = 5; return &x; } hatalıdır: f dönünce x’in kaydı yığından kalkar, pointer artık geçersiz bir yeri gösterir. Fonksiyonun ömrünü aşacak veri için malloc kullan.

printf

int age = 20;
double gpa = 3.456;
char grade = 'B';
printf("Age: %d, GPA: %.2f, Grade: %c\n", age, gpa, grade);

Age: 20, GPA: 3.46, Grade: B

Kaçış dizileri: \n satır sonu, \t sekme, \\ ters bölü, \" tırnak.

printf, yazdığı karakter sayısını döndürür: printf("abc\n") 4 döndürür.

scanf

int a, b;
int n = scanf("%d %d", &a, &b);

• Değişkenin adresi verilir (&a). scanf okuduğunu o adrese yazar.
• String okurken & konmaz, çünkü dizi adı zaten adrestir: scanf("%9s", word);. Genişlik (9) taşmayı önler.
• Dönüş değeri başarıyla okunan öğe sayısıdır. Kullanıcı 12 30 yazarsa n = 2.
• %d boşlukları ve satır sonlarını atlar.

LC-3 düzeyinde printf ve scanf, sonunda TRAP x21 (OUT) ve TRAP x20 (GETC) gibi işletim sistemi rutinlerini çağırır. Biçimlendirme (sayıyı ASCII rakamlara çevirmek) kütüphanenin işidir; 10. haftada x30 ekleyerek yaptığın şeyin genel hali.

Sık yapılan hatalar

struct point { int x; int y; };
/* in main: */
struct point p = {3, 4};
p.x += 2;
printf("%d %d\n", p.x, p.y);

void moveBad(struct point p)   { p.x += 10; }
void moveGood(struct point *p) { p->x += 10; }
/* in main: */
struct point p = {1, 2};
moveBad(p);   printf("%d ", p.x);
moveGood(&p); printf("%d\n", p.x);

struct point a = {5, 6};
struct point b = a;
b.y = 0;
printf("%d %d\n", a.y, b.y);

typedef struct { char name[12]; int score; } Student;
/* in main: */
Student s[3] = {{"Ada", 70}, {"Can", 85}, {"Ece", 60}};
int i, best = 0, sum = 0;
for (i = 0; i < 3; i++) {
    sum += s[i].score;
    if (s[i].score > s[best].score) best = i;
}
printf("%s %d\n", s[best].name, sum / 3);

struct node { int val; struct node *next; };
/* in main: */
struct node c = {30, NULL}, b = {20, &c}, a = {10, &b};
struct node *p;
int s = 0;
for (p = &a; p != NULL; p = p->next)
    s += p->val;
printf("%d %d\n", s, a.next->next->val);

printf("[%5d][%-5d][%05d]\n", 42, 42, 42);

printf("%.2f %8.3f|\n", 3.14159, 3.14159);

printf("%x %X %o %c\n", 255, 255, 8, 65);

int a, b;
int n = scanf("%d %d", &a, &b);
printf("%d %d %d\n", n, a, b);

int *v = malloc(4 * sizeof(int));
int i;
for (i = 0; i < 4; i++) v[i] = i * i;
printf("%d %d\n", v[3], v[1] + v[2]);
free(v);

struct point pts[2] = {{1, 2}, {3, 4}};
struct point *q = pts;
q++;
printf("%d %d\n", q->x, (*q).y + pts[0].x);