Önişlemci Bildirimleri #define, #include – C Programlama Dili

C dilinde derleme işlemi öncesi derleyiciye bazı bildirimlerde bulunan proprocessor dediğimiz önişlemci komutları vardır. Bunlardan bazılarını programlarımızda her zaman kullanıyoruz: include gibi.

Bugün bu önişlemci direktiflerinden en çok kullanılanlarına değineceğiz.

#include

C programlama dili derslerinin başında C dilinde en çok kullanılan fonksiyonların kütüphane dosyaları dediğimiz .lib uzantılı dosyalarda yer aldığından bahsetmiştik. Bu kütüphane dosyalarının prototipleri ise başlık dosyası dediğimiz (header) .h uzantılı dosyalarda yer alır.

Programlarımızda standart kütüphanelerdeki fonksiyonları kullanacaksak, kullanmak istediğimiz fonksiyonun dahil olduğu kütüphanenin header dosyasını #include direktifini kullanarak kodumuza dahil etmemiz gerekir.

#include <stdio.h>         // 1.Kullanım

Ya da

#include “stdio.h”           // 2.Kullanım

gibi. Performans olarak  birinci kullanım daha çok tercih edilir.

Sürekli kullandığımız için uygulama yapmaya gerek görmüyorum.

#define

#define (proprocessor directive) önişlemci  direktifi, C dilinde macro tanımlamaya imkan verir.

Daha açık ifade etmek gerekirse #define, bir programda kullanmak isteyebileceğimiz sabit ifadeler, metotlar veya sorguları tanımlamak için kullanılır.

#define kullanımı önemlidir. Duruma göre hem programcıya kolaylık sağlar hem de programın okunabilirliğini artırır.

Genel yapısı aşağıdaki gibidir :

#define MAKROADI makro-degeri

Makro isimlendirirken makro adının büyük harflerle yazılması şeklinde C dilinde gelenekselleşmiş bir kullanım vardır.

Derleme başlamadan önce proprocessor, MAKROADI olarak belirttiğimiz bu tanımları alır ve programda bu sembolleri gerçek değerleri ile değiştirir.

Bu kadar açıklamanın ardından ufak bir uygulama yapalım :

Uygulama kullanıcıdan alınan yaricap değerine göre dairenin alanını hesaplamaktadır. Programın başında float tipinde adı yaricap ve değeri 0 olan bir değişken tanımladık. Sonrasında verilen  printf() fonksiyonları ise tamamen bilgilendirme amaçlıdır.

Eğer kullanıcı uygulamadan çıkmak istiyorsa yarıçapa negatif bir değer girmesi yeterlidir.

Sonrasında verilen while ifadesi ise sonsuz bir döngüyü temsil etmektedir:

while(1)

{

                //stataments;

}

Program sonsuz bir döngü içerisinde sürekli kullanıcıdan alınacak değere göre daire alanını hesaplayacak ve ekrana bu değeri yazdıracaktır.

Kullanıcının programa devam etme ya da çıkma isteğini while() döngüsü içerisindeki if yapısına bağladık.

Kullanıcı ne zaman uygulamadan çıkmak için negatif bir değer girerse o zaman sonsuz döngü if yapısı içerisinde verilen

break;

anahtar kelimesi sayesinde uygulamadan çıkacak ve ekrana

“Uygulamadan çıkıldı.”

yazacaktır.

Programın en başında PI olarak tanımladığımız sabit'in değeri olarak verdiğimiz 3.14 değeri uygulamada PI yazılan yere konulacak.

#define direktifini sadece sabit değerler için kullanmayız elbette. Mesela aşağıdaki uygulamaya bakalım :

Uygulamamız bir integer dizisi içerisindeki en büyük ve en küçük değerleri hesaplamak için yazıldı.

Uygulamanın başında

int sayilar[7] = {9,5,2,10,4,1,6}; //sayılar dizisi

kodu ile 7 elemanlı bir int dizi tanımlayıp ilk değer ataması yapıyoruz. Sonrasında

int min = 0, max = 0;

ifadesi ile int tipinde min, max değişkenlerini tanımlayıp ilk değer olarak 0 ataması yapıyoruz. Sonrasındaki printf() fonksiyonları ise bilgilendirme amaçlıdır.

Gelelim for döngüsüne. Döngü, dizi eleman sayısı kadar dönecektir ve burada kullanılan kontrol değişkenimiz olan i değişkeni, dizi index değeri olarak da kullanılmıştır.

Döngünün ilk dönüşünde dizinin birinci ve ikinci elemanları birbiri ile karşılaştırılıp minimum ve maximum değerleri min ve max değerlerine atanıyor.

max = MAX(sayilar[i],sayilar[i+1]);
min = MIN(sayilar[i],sayilar[i+1]);

Karşılaştırma #define ile tanımladığımız bir makro sayesinde yapılıyor.

• define MAX(X,Y) ((X)>=(Y)?(X):(Y))
• define MIN(X,Y) ((X)<=(Y)?(X):(Y))

Sonrasında her bir dizi elemanı ile max ve min değerleri karşılaştırılıp değerlerin güncelleniyor döngü sonuna kadar durum böyle devam ediyor. Çıktımız aşağıdaki gibidir :

Görüldüğü gibi program düzgün çalıştı.

Bu uygulamada kullandığımız gibi bir makro tanımlarken kullandığımız değişkenleri () parantezleri arasına koymak zorundayız yoksa hatalı bir tanımlama yapmış oluruz.

#define ile fonksiyonlara benzer yapılar da tanımlanabilir ancak fonksiyonlar daha gelişmiş yapılar olduğundan -gereksiz bulduğum için- onların örneğini vermeyeceğim.

Şimdi de #define kullanarak bir programlama dili nasıl Türkçeleştirilir onu gösterelim :

Uygulamamızda kullandığımız #define direktifleri aşağıdaki gibidir :

• define ekranaYaz printf
• define degerAl scanf

Yani bu kod ile derleyicimize; ekranaYaz gördüğün yere printf, degerAl gördüğün yere de scanf yazdıktan sonra programı derle diyoruz.

Böylelikle uygulamada gördüğünüz gibi biz sanki C dili, Türkçe fonksiyonlara sahipmiş gibi kullanabiliriz.

Uygulamamızın çıktısı aşağıdaki gibidir :

#undef

#undef önişlemci komutu ise #define önişlemci komutu ile tanımladığımız şeyleri iptal etmek için kullanılır.

Programın herhangi bir noktasına

#undef PI

Dediğimiz an o noktadan itibaren PI artık anlamsızdır. Uygulamasını görelim :

Çıktımız :

C Dili'nde Sabit Tanımlama ( const ve #define farkı)

C dilinde sabitler, normal değişken tanımlanır gibi tanımlanır. Normal değişkenlerden tek farkı bir kez değer ataması yapıldıktan sonra değerinin değiştirilemez olmasıdır.

Genellikle PI tarzı sabit bir değere sahip olan değerler için kullanılır. Her veri tipinin sabit hali olabilir.

Genel yapısı aşağıdaki gibidir :

Teoride const anahtar kelimesi ya da #define önişlemci bildirimi ile sabit tanımlamak mümkündür. Hatta const sabitini de global tanımlayarak programın her yerinden erişim imkanı da sağlayabilirsiniz.

#define ön işlemcisinde, derleyici programı derlemeye başlamadan önce bu bildirimlere bakar ve sabit olarak belirtilen sembollerin yerine sabit değerini yazdıktan sonra derler. Yani bu sabitleri tutmak için hafızada bir yer ayırmaz.

Ancak const tanımlanan değişkenler, sonuç itibariyle değişken olduklarından bellekte bir yer kaplar ve derleyicinin programı derlerken bunları yorumlaması kadar da zaman ayırır.

Yani #define, const ile karşılaştırıldığından tabii ki daha hızlıdır.

Örneğin TIME diye bir değeriniz olsun ve bu değer programın birçok noktasında kullanılacak olsun. İleride olur da TIME değerini değiştireceğinizi göz önünde bulundurursak, TIME kavramını #define ile tanımlamak daha mantıklı olacaktır.

#define TIME 100

Ya da bir microcontroller programı yazıyorsunuz belli pin değerlerini uygulamanın bazı noktalarında kullanacaksınız. Bunun için de yine #define kullanılabilir.

#define LEDPIN 11

Gibi.

Const ise daha çok değiştirmek istemediğimiz değişkenler için kullanılır.

const anahtar kelimesi ile değişken tanımlamanın #define ile tanımlama noktasındaki avantajlarından biri tip kontrolü olmasıdır. Ayrıca const ile pointer sabit de tanımlayabiliriz. Ya da diğer değişkenlerle yapabileceğimiz her şeyi const değişkenlerle de yapabiliriz. Olayı bu açıdan ele aldığımızda const ı direk sabit değil de Read Only bir değişken olarak görmek gerekiyor.

Bugünlük bu kadar, umarım faydalı bir çalışma olmuştur.

Uygulama noktasında herhangi bir sorun yaşarsanız aşağıdaki yorum panelini kullanarak iletişime geçmekten çekinmeyin lütfen. Teşekkürler.

Kaynak belirtilmeyen görseller @etasarim a aittir. / Pictures that don’t have any source belongs to @etasarim.

---

Posted from my blog with SteemPress : http://etasarim.cloudaccess.host/17/03/2019/onislemci-bildirimleri-define-include-c-programlama-dili/

---