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 sabit | const |
Bir dizi boyutu, bir case etiketi, bir bit alanı genişliği | enum ya da #define |
| Bir metin sabiti | #define ya da const char * |
| Bir kayan noktalı sabit | const double |
| İlişkili tam sayı değerlerinden bir küme | enum |
Ö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;
}