berzahx 1
berzahx
aslan6474 1
aslan6474
Reklam vermek için turkmmo@gmail.com

C'de Başlık Dosyaları: Modüler Programlama ve Include Korumaları

  • Konuyu başlatan Konuyu başlatan Agora Metin2
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 0
  • Görüntüleme Görüntüleme 5
imagee901b4708a2f3b6d.jpg


Küçük projelerde her şeyi tek bir .c dosyasında toplamak sorun yaratmasa da, proje büyüdükçe kodu bölümlere ayırmak kaçınılmazdır. Kodun parçalanması; birimlerin bağımsız derlenmesini, okunabilirliğin artmasını ve fonksiyonların farklı projelerde tekrar kullanılmasını sağlar. C dili modern dillerdeki gibi gelişmiş bir "import" mekanizmasına sahip değildir; bunun yerine metin kopyalayan bir ön işlemci ve parçaları birleştiren bir bağlayıcı (linker) kullanır.

Başlık dosyaları (.h), farklı kod parçaları arasındaki mutabakat metinleridir. Bir fonksiyonun veya değişkenin gerçek kodunu (gerçekleştirimini) sunmadan, diğer dosyalara o varlığın neye benzediğini bildirirler.

Bildirim ile Tanım Arasındaki Fark

Modüler yapının temeli bu iki kavramın ayrılmasına dayanır.

Bildirim (Declaration), bir yapının var olduğunu ve özelliklerini tanıtır. Bellekte yer ayırmaz, kod üretmez ve program içinde istenildiği kadar tekrar edilebilir:

C:
int add(int a, int b);        /* fonksiyon bildirimi (prototip) */
extern int error_count;       /* değişken bildirimi */
struct Point { int x, y; };   /* tür tanımı - dosya başına tekrarlanması güvenli */

Tanım (Definition) ise yapıyı somut olarak oluşturur. Tüm program boyunca sadece bir kez yapılmalıdır:

C:
int add(int a, int b) { return a + b; }   /* fonksiyon tanımı */
int error_count = 0;                      /* değişken tanımı */

Genel kural şudur: Başlık dosyaları bildirimleri, kaynak dosyalar ise tanımları barındırır. Eğer bir tanımı başlık dosyasına yazarsanız, bağlayıcı "multiple definition of..." hatası vererek işlemleri durduracaktır.

Çok Dosyalı Yapı Örneği

İki fonksiyon içeren basit bir modül yapısını inceleyelim. Önce fonksiyonları bildiren başlık dosyası:

C:
/* math_utils.h */
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int max_of(int a, int b);

#endif

Bu fonksiyonların gövdesini içeren kaynak dosya (dikkat ederseniz kendi başlık dosyasını da dahil ediyor):

C:
/* math_utils.c */
#include "math_utils.h"

int add(int a, int b) {
    return a + b;
}

int max_of(int a, int b) {
    return (a > b) ? a : b;
}

Ve bu modülü kullanan ana program dosyası:

C:
/* main.c */
#include <stdio.h>
#include "math_utils.h"

int main(void) {
    printf("add(3, 4)    = %d\n", add(3, 4));
    printf("max_of(3, 4) = %d\n", max_of(3, 4));
    return 0;
}

Bu dosyaları bir arada derlemek için şu komut kullanılır:

Bash:
gcc main.c math_utils.c -o app
./app

Burada iki önemli nokta öne çıkıyor. Birincisi, math_utils.c dosyasının kendi .h dosyasını dahil etmesidir. Bu sayede derleyici, fonksiyon tanımlarının başlıktaki prototiplerle uyumlu olup olmadığını kontrol eder; bir hata varsa bağlama aşamasını beklemeden sizi uyarır.

İkincisi, math_utils.h dosyasının derleme komutuna dahil edilmemesidir. Başlık dosyaları derlenmez; sadece #include komutuyla kaynak dosyaların içine kopyalanırlar.

Yukarıdaki yapının, tek bir dosyada birleştirilmiş hali ise şöyledir:

C:
#include <stdio.h>

/* math_utils.h'nin bildirecegi seyler */
int add(int a, int b);
int max_of(int a, int b);

int main(void) {
    printf("add(3, 4)    = %d\n", add(3, 4));
    printf("max_of(3, 4) = %d\n", max_of(3, 4));
    return 0;
}

/* math_utils.c'nin tanimlayacagi seyler */
int add(int a, int b) {
    return a + b;
}

int max_of(int a, int b) {
    return (a > b) ? a : b;
}

Buradaki fonksiyon prototipleri, aslında başlık dosyalarının yaptığı işin aynısını yerel ölçekte gerçekleştirir.

Include Korumaları (Include Guards)

#include komutu, hedef dosyanın içeriğini olduğu gibi kopyalar. Eğer bir dosya yanlışlıkla iki kez dahil edilirse, içerik de yinelenmiş olur. Bu durum fonksiyon bildirimlerinde sorun yaratmasa da, struct tanımlarında derleme hatasına yol açar:

C:
/* KORUMASIZ shapes.h */
struct Point { int x, y; };

Karmaşık projelerde dosyalar birbirini zincirleme olarak dahil edebilir. Bu iç içe geçme durumunda "redefinition of struct" hatası almamak için "include koruması" kullanılır. Bu yöntem, bir makro aracılığıyla dosyanın daha önce eklenip eklenmediğini denetler:

C:
/* shapes.h */
#ifndef SHAPES_H
#define SHAPES_H

struct Point { int x, y; };
struct Point origin_point(void);

#endif /* SHAPES_H */

Sistem şöyle işler: SHAPES_H makrosu tanımlanmamışsa içerik işlenir ve makro tanımlanır. Dosya aynı birimde tekrar dahil edilmeye çalışıldığında makro zaten tanımlı olduğu için derleyici doğrudan #endif kısmına atlar.

Modern derleyicilerde daha kısa bir alternatif de mevcuttur:

C:
/* shapes.h */
#pragma once

struct Point { int x, y; };

#pragma once kullanımı daha pratiktir ve yazım hatalarına karşı daha güvenlidir. Ancak standart bir C kuralı olmadığı için çok eski veya nadir derleyicilerde çalışmayabilir. Her halükarda, yazdığınız her başlık dosyasına bu korumalardan birini mutlaka eklemelisiniz.

Başlık Dosyasına Neler Konulmalıdır?

.h dosyalarında bulunması gerekenler:

• Fonksiyon prototipleri
• Yapı (struct), birlik (union) ve numaralandırma (enum) kalıpları
• typedef tanımlamaları
• Dışarıya sunulacak makrolar
• Küresel değişkenlerin extern bildirimleri
• Dosyanın kendi başına çalışması için gereken diğer #include satırları

Kaçınılması gerekenler:

• Fonksiyonların gövdeleri (özel durumlar hariç)
• Değişken tanımları (başlığa int sayac; yazmak, her dosyada yeni bir değişken oluşturur ve çakışmaya neden olur)
• Gereksiz kütüphane dahil etmeleri

İyi bir başlık dosyası "kendi kendine yeterli" olmalıdır. Örneğin bir başlıkta size_t kullanılıyorsa, onu dahil eden dosyanın <stddef.h>'ı eklemiş olmasını beklemek yerine, başlık dosyası bu kütüphaneyi kendisi içermelidir.

Örnek bir başlık dosyası şablonu:

C:
/* inventory.h */
#ifndef INVENTORY_H
#define INVENTORY_H

#include <stddef.h>   /* aşağıda kullanılan size_t için */

#define MAX_NAME 64

typedef struct {
    char   name[MAX_NAME];
    int    quantity;
    double price;
} Item;

/* program genelinde paylaşılır, inventory.c'de bir kez tanımlanır */
extern int item_count;

void   inventory_add(const Item *item);
double inventory_total(void);
size_t inventory_size(void);

#endif /* INVENTORY_H */

Küresel Değişkenlerin Paylaşımı (extern)

Bir küresel değişkeni birden fazla dosyada kullanmak için değişken bir .c dosyasında tanımlanmalı, başlık dosyasında ise extern ile bildirilmelidir:

C:
/* inventory.h  - bildirim, depolama yok */
extern int item_count;

C:
/* inventory.c  - tek tanım */
#include "inventory.h"
int item_count = 0;

C:
/* main.c - başlık üzerinden kullanır */
#include <stdio.h>
#include "inventory.h"

int main(void) {
    printf("%d oge\n", item_count);
    return 0;
}

Eğer extern anahtar kelimesini kullanmazsanız, her dosya kendine ait bağımsız bir değişken oluşturur veya bağlama hatası alırsınız.

Bunun tam tersi olarak, sadece tanımlandığı dosyaya özel kalması gereken değişkenler için static kelimesi kullanılır. Bu, değişkeni dış dünyaya kapatır:

C:
/* inventory.c */
static Item storage[256];                  /* bu dosyaya özel */
static int  find_slot(const char *name);   /* özel yardımcı */

Derleme Süreçlerini Yönetmek

Çok sayıda dosyayı tek bir komutla derlemek yavaştır çünkü bir dosyayı değiştirseniz bile her şey baştan derlenir:

Bash:
gcc main.c inventory.c report.c -o app

Daha verimli yöntem, önce nesne (.o) dosyaları oluşturmak ve sonra bunları bağlamaktır:

Bash:
gcc -c main.c        # main.o üretir
gcc -c inventory.c   # inventory.o üretir
gcc -c report.c      # report.o üretir
gcc main.o inventory.o report.o -o app

Bu süreci otomatikleştirmek için genellikle make gibi araçlar kullanılır:

Kod:
app: main.o inventory.o report.o
	gcc main.o inventory.o report.o -o app

%.o: %.c
	gcc -Wall -Wextra -c $< -o $@

Eğer başlık dosyalarınız farklı bir klasördeyse (örneğin "include" klasörü), derleyiciye bunu -Iinclude parametresiyle bildirebilirsiniz.

Sık Karşılaşılan Hatalar

Hata mesajlarının hangi aşamada geldiğini anlamak çözümü kolaylaştırır:

"undefined reference to..." - Bağlayıcı hatasıdır. Fonksiyonun bildirimi vardır ama gövdesi (tanımı) bulunamamıştır. Dosyayı derleme komutuna eklememiş olabilirsiniz.

"multiple definition of..." - Bağlayıcı hatasıdır. Bir değişken veya fonksiyon tanımı birden fazla yerde (veya bir başlık dosyasında) yapılmıştır.

"redefinition of 'struct...'" - Derleyici hatasıdır. Aynı yapı tanımı bir dosyaya birden fazla kez kopyalanmıştır. Include koruması kullanmalısınız.

"implicit declaration of function..." - Derleyici uyarısıdır. Fonksiyonun prototipi derleyici tarafından görülmemiştir. İlgili .h dosyasını dahil etmeyi unutmuş olabilirsiniz.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst