Agora Metin2 1
Agora Metin2
berzahx 1
berzahx
Aliyldrim 1
Aliyldrim
-ECD- 1
-ECD-
Reklam vermek için turkmmo@gmail.com

C Dilinde Sabitlerin Kullanımı: const, #define ve enum

  • 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 12
imagee901b4708a2f3b6d.jpg


Sabitler, belirli bir ismi olan ve değerinin değiştirilmeyeceği garanti edilen verilerdir. C dili bu işlem için üç farklı yöntem sunar; ancak bu yöntemler arka planda farklı şekilde çalışır: biri değişken, diğeri metin değiştirme, üçüncüsü ise bir tam sayı türüdür.

Değerleri Adlandırmanın Avantajları

Aşağıdaki iki kullanım örneğini kıyaslayın:

C:
double area = 3.14159 * r * r;
double area = PI * r * r;

İkinci yöntem, şu üç temel sebepten dolayı çok daha avantajlıdır: Öncelikle sayının neyi temsil ettiği açıkça belirtilir. İkincisi, değer tek bir noktada tanımlandığı için hassasiyet ayarını değiştirmek tüm kodu taramak yerine sadece tek bir satırı düzenlemek anlamına gelir. Üçüncüsü, PI isminde yapılacak bir yazım yanlışı derleme aşamasında hata verirken, 3.14195 gibi bir rakamda yapılacak hata yanlış sonuçlara yol açar.

Kodun çeşitli yerlerine rastgele yerleştirilmiş isimsiz sayılara "sihirli sayılar" denir. Bu sayıları temizlemek, bir C programında yapılabilecek en kolay ve etkili iyileştirmelerden biridir.

const Kullanımı

const anahtar kelimesi, bir değişkenin sadece okunabilir olduğunu belirtir:

C:
#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("r=%.1f icin alan: %.4f\n", r, PI * r * r);
    printf("Kapasite: %d kullanici\n", MAX_USERS);

    /* PI = 3.0;  <- bu satiri yorumdan cikarin, program derlenmeyecek */
    return 0;
}

Eğer atama satırını aktif ederseniz, derleyici "assignment of read-only variable 'PI'" hatası vererek işlemi reddedecektir. İşte asıl amaç, bu hatayı çalışma zamanında değil, derleme aşamasında yakalamaktır.

const ile tanımlanan yapılar aslında gerçek birer değişkendir. Bir türleri olduğu için derleyici tarafından denetlenirler, kapsam (scope) kurallarına uyarlar (örneğin bir fonksiyon içindeki const dışarıya sızmaz), bir bellek adresleri vardır ve dolayısıyla onlara gösterici (pointer) ile erişilebilir. Ayrıca hata ayıklayıcılar (debugger) bu değişkenlerin adını ve değerini gösterebilir.

const değişkenlerin, tanımlandıkları anda ilk değerlerinin verilmesi zorunludur:

C:
const int limit;       /* hata (ya da sonsuza dek çöp): sonradan hiçbir şey atayamaz */
const int limit = 50;  /* doğru */

#define Makroları

Ön işlemci (preprocessor) tarafından sağlanan alternatif yöntem makrolardır:

C:
#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Sisteme hos geldiniz"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("r=%.1f icin alan: %.4f\n", r, PI * r * r);
    printf("Kapasite: %d kullanici\n", MAX_USERS);
    return 0;
}

Bu yapı bir değişken değildir. Derleme işlemi başlamadan önce ön işlemci, kod içerisindeki her PI ifadesini 3.14159265358979 karakterleriyle değiştirir. Derleyici bu ismi hiç görmez; bu yüzden #define yapılarının bir türü yoktur ve hata ayıklayıcılarda görünmezler.

Burada eşittir = işareti veya noktalı virgül kullanılmadığına dikkat edin. Makrolar basit metin değişimleri olduğu için şu yaygın hata:

C:
#define MAX_USERS 100;        /* noktalı virgüle dikkat */

int limit = MAX_USERS + 1;    /* şuna genişler: int limit = 100; + 1;  -> hata */

hiç alakası yokmuş gibi görünen bambaşka bir satırda hata üretilmesine neden olabilir. Makrolarda büyük harf kullanma geleneği, kod okuyucularının bunun bir metin değişimi olduğunu anlaması içindir.

Genellikle makrolar BUYUK_HARF ile yazılır; aynı amacı taşıdıkları için const değişkenler de sıklıkla bu isimlendirme yöntemini takip eder.

Enum Sabitleri

Üçüncü yöntem, adlandırılmış tam sayılardan oluşan bir grup tanımlamanızı sağlar:

C:
#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* gercek bir derleme zamani sabiti */

    printf("tampon %zu bayt tutuyor\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, bugun=%d\n", MON, TUE, WED, today);
    return 0;
}

Siz aksini belirtmediğiniz sürece değerler 0'dan başlar ve birer birer artar. Bu örnekte MON 0, FRI ise 4 değerini alır. İsimsiz bir enum { ... } kullanımı, düz tam sayı sabitleri oluşturmak için sıkça başvurulan bir yöntemdir.

Enum sabitlerinin diğer iki yönteme göre belirgin bir üstünlüğü vardır: Hem derleyicinin anladığı gerçek derleme zamanı tam sayı sabitleridir hem de hata ayıklayıcılar tarafından görünürler.

Hangi Yöntem Tercih Edilmeli?

İhtiyaçKullanın
Türlü, kapsamlı, hata ayıklanabilir bir sabitconst
Bir dizi boyutu, bir case etiketi, bir bit alanı genişliğienum ya da #define
Bir metin sabiti#define ya da const char *
Bir kayan noktalı sabitconst double
İlişkili tam sayı değerlerinden bir kümeenum
Ön işlemcinin görmesi gereken her şey (#if, include korumaları)#define

Genel kural olarak öncelikli tercih const olmalıdır. Eğer değerin derleme işleminden önce mevcut olması gerekiyorsa #define, adlandırılmış bir tam sayı grubuna ihtiyaç duyuluyorsa enum kullanılmalıdır.

Bu yöntemlerin farkının gerçekten hissedildiği tek nokta dizi boyutlarıdır:

C:
#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* sorunsuz */
int global_b[ENUM_SIZE];      /* sorunsuz */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* C99 degisken uzunluklu dizi - burada calisir... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("kureseller: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

C dilinde const int, derleme zamanı sabit ifadesi değil, sadece salt okunur bir değişkendir. C99 standardında, bir fonksiyon içinde int local[const_size] kullanımı "değişken uzunluklu dizi" olarak kabul edilir ve çalışır; ancak dosya kapsamında, bir struct içerisinde veya bir case etiketi olarak kullanıldığında doğrudan hata verir. enum ve #define ise tüm bu durumlarda sorunsuz çalışır.

(Bu durum, const int'in bir sabit ifadesi olarak kabul edildiği C++ ile C arasındaki temel farklardan biridir ve iki dil arasında taşınan kodlarda sorun yaratabilir.)

const ve Göstericiler

const ve göstericilerin birleşimi üç farklı anlama gelir ve bunlar birbirinin yerine kullanılamaz. Tanımı, isimden dışarıya doğru okumak gerekir:

C:
const char *p;          /* p, değiştirilmemesi gereken char'ları gösterir */
char * const q;         /* q'nun kendisi yeniden yönlendirilemez; char'lar değişebilir */
const char * const r;   /* ne gösterici ne de char'lar değişebilir */

C:
#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- hata: veri p uzerinden const */
    p = "world";  /* ama p'yi yeniden yonlendirmek sorunsuz */
    printf("p simdi sunu gosteriyor: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* veriyi q uzerinden degistirmek sorunsuz */
    /* q = "world";  <- hata: q'nun kendisi const */
    printf("text simdi: %s\n", text);
    return 0;
}

En sık karşılaşacağınız yapı const char * biçimidir. Bu yapı, bir metni değiştirmeden sadece okuması gereken fonksiyon parametreleri için en uygun türdür:

C:
#include <stdio.h>

/* const, cagirana soz verir: bu fonksiyon metninizi degistirmeyecek. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("\"programming\" icindeki unluler: %zu\n", count_vowels("programming"));
    return 0;
}

Salt okunur bir parametreye const eklemek hiçbir ek maliyet getirmez, ancak bu durumun derleyici tarafından denetlenmesini sağlayarak kodun amacını belgeler. Bu yöntem her zaman tercih edilmelidir.

Metin Sabitlerinin Doğası

const kullanımının önlediği kritik bir tuzak şudur:

C:
char *s = "hello";   /* geçerli C, ama s salt okunur belleği gösterir */
s[0] = 'H';          /* tanımsız davranış - genellikle bir çökme */

Metin sabitleri, çalıştırılabilir dosyanın salt okunur bir bölümünde saklanır. Bu gösterici üzerinden veri yazmaya çalışmak genellikle "segfault" (segmentasyon hatası) ile sonuçlanır. Göstericiyi const char *s = "hello"; şeklinde tanımlamak, programın çalışma zamanında çökmesi yerine, derleyicinin bu hatalı atamayı daha önce reddetmesini sağlar.

Eğer üzerinde değişiklik yapılabilecek bir metne ihtiyaç duyuyorsanız, bunu bir diziye kopyalamanız gerekir:

C:
#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* salt okunur, degistirilemez */
    char copy[] = "hello";           /* bir dizi: ozel, degistirilebilir bir kopya */

    copy[0] = 'H';
    printf("sabit: %s\n", literal);
    printf("kopya: %s\n", copy);
    return 0;
}
 

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

Geri
Üst