C'de Sabitler: const, #define ve enum

Sabit, bir ismi ve değişmeyeceği sözü olan bir değerdir. C bunun için size üç mekanizma verir ve bunlar perde arkasında gerçekten farklı şeylerdir - biri bir değişken, biri metin değiştirme, biri de bir tam sayı türüdür.

Bir Değeri Neden Adlandırmalı

Şu iki satırı karşılaştırın:

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

İkincisi, hepsi sonradan ortaya çıkan üç sebeple daha iyidir. Sayının ne anlama geldiğini söyler. Tam olarak tek bir yerde görünür, dolayısıyla hassasiyeti değiştirmek bir arama değil, tek bir düzenlemedir. Ve PI'daki bir yazım hatası bir derleme hatasıdır, oysa 3.14195'teki bir yazım hatası yanlış bir cevaptır.

Kodun içine serpiştirilmiş isimsiz sayılara sihirli sayılar denir ve onları kaldırmak bir C programında yapabileceğiniz en ucuz iyileştirmelerden biridir.

const

const anahtar kelimesi bir değişkeni salt okunur olarak işaretler:

#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;
}

Atamayı yorumdan çıkarın, derleyici reddeder: assignment of read-only variable 'PI'. Derleme zamanındaki o hata, meselenin tamamıdır.

Bir const değişken gerçek bir değişkendir. Bir türü vardır, dolayısıyla derleyici onu nasıl kullandığınızı denetler. Kapsama uyar, dolayısıyla bir fonksiyonun içindeki const dışarı sızmaz. Bir adresi vardır, dolayısıyla ona bir gösterici alabilirsiniz. Ve bir hata ayıklayıcı size adını ve değerini gösterebilir.

const'a bildirim noktasında ilk değer verilmelidir - ikinci bir şans yoktur:

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

#define

Ön işlemci alternatifi bir makrodur:

#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 bir değişken değildir. Derleyici çalışmadan önce ön işlemci, kaynaktaki her PI geçişini 3.14159265358979 karakterleriyle değiştirir. Derleyici ismi hiç görmez - bir #define'ın neden türü olmadığı ve hata ayıklayıcıda görünemediği tam olarak budur.

Noktalı virgül ve = olmadığına dikkat edin. Makro ham metindir, dolayısıyla şu yaygın hata:

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

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

tanıma hiç benzemeyen bir satırda hata üretir. Makrolar için büyük harf adlandırma geleneği, tam da okuyucuların bir değiştirme olduğunu bilmesi için vardır.

Makrolar geleneksel olarak BUYUK_HARF yazılır; const değişkenler aynı fikri temsil ettiklerinde genellikle bunu izler.

Enum Sabitleri

Üçüncü biçim size adlandırılmış tam sayılardan oluşan bir küme verir:

#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 atama yapmadıkça değerler 0'dan başlar ve birer birer artar, dolayısıyla MON 0 ve FRI 4'tür. İsimsiz bir enum { ... }, düz tam sayı sabitleri için yaygın bir deyimdir.

Enum sabitlerinin her iki alternatife göre gerçek bir üstünlüğü vardır: derleyicinin anladığı derleme zamanı tam sayı sabitleridir ve hata ayıklayıcıya görünürler. Tüm hikâye C'de enum'lar sayfasında.

Hangisini Kullanmalı

Varsayılan const olmalıdır. Değerin derlemeden önce var olması gerektiğinde #define'a, derleme zamanı tam sayısı ya da adlandırılmış bir gruba ihtiyacınız olduğunda enum'a uzanın.

Bunun gerçekten canınızı yaktığı tek yer dizi boyutlarıdır:

#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'de bir const int, bir derleme zamanı sabit ifadesi değil, salt okunur bir değişkendir. Bir fonksiyonun içinde C99, int local[const_size]'ı değişken uzunluklu bir dizi yaparak kabul eder; dosya kapsamında, bir struct içinde ya da bir case etiketi olarak doğrudan reddedilir. enum ve #define her yerde çalışır.

(Bu, const int'in bir sabit ifadesi olduğu C++'tan gerçek farklardan biridir. Diller arasında dolaşan kod buna takılır.)

Göstericilerle const

const ve göstericiler üç şekilde birleşir ve anlamları birbirinin yerine geçmez. Bildirimi isimden dışarı doğru okuyun:

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 */

#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;
}

const char * biçimi en çok yazacağınız olandır, çünkü bir metni değiştirmeden okuyan bir fonksiyon parametresi için doğru türdür:

#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 şeye mal olmaz ve sözleşmeyi derleyicinin uyguladığı bir biçimde belgeler. Her yerde yapmaya değer.

Metin Sabitleri Fiilen const'tur

const'ın yakalamak için var olduğu ince bir tuzak:

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 yaşar. O göstericiden yazmak tipik olarak segfault verir. Göstericiyi const char *s = "hello"; diye bildirmek, derleyicinin çalışma zamanında çökmesine izin vermek yerine atamayı reddetmesini sağlar.

Değiştirilebilir bir metne ihtiyacınız varsa onu bir diziye kopyalayın:

#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;
}