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; /* arttırma işlemleri */
b = b * 5;
a = b = c = 20; /* Çoklu atamalar */
a = b = c = 12*13/4;
}
================================================================
Bu programda üç tam sayı değişkeni tanımlıyoruz (a,b,c), ve bunlara değerler atıyoruz. İlk iki satırda a ve b ye sayısal değerler veriyoruz. Daha sonraki dört satırda, basit işlemler görüyorsunuz.
Besinci satırda ise, modulo operatörünü görüyorsunuz. Modulo, iki değişken birbirine bölündüğünde, kalan değeri verir. Modulo, sadece integer ve char değişken tipleri ile kullanılabilir.
Örneğin 10%3 işlemi 1 döndürecektir, çünkü 10’u 3’e bölünce 1 kalacaktır.
Daha sonra gelen iki arttırma işlemleri ise, bu şekilde derleyici tarafından kabul edilir, fakat bunları yazmanın daha kestirme bir sekli vardır – bunu daha sonra göreceğiz.
Son iki satıra gelince, bunlar çok tuhaf görünebilir göze. C derleyicisi, atama satırlarını, sağdan sola doğru okur. Bunun sayesinde, çoklu atamalar gibi, çok faydalı işlemler yapılabilir. Bu örnekte, derleyici, yirmiyi alıp, c ye atıyor. Sola doğru devam ederken, b yi görüp, en son elde edilen sonucu (20) b ye atıyor Ayni şekilde a ya da, b nin değeri veriliyor.
Bu programı derleyip, çalıştırmak son derece sıkıcı olabilir. Bu programın hiçbir çıktısı yoktur. Dilerseniz, öğrendiğiniz printf fonksiyonu ile, programın yaptıklarını daha yakından inceleyebilirsiniz.
C de veri tanımları, program bloku içinde, islenecek komutlardan önce gelir. Şayet tanımları programın ortasına yerleştirmeye çalışırsanız, derleyici bir hata verecektir.
VERI TIPLERI
main()
{
int a,b,c; /* -2147483647 den 2147483647 ye; tamsayi olarak */
char x,y,z; /* 0 dan 255 e ... tamsayi olarak */
float num,toy,thing; /* 10e-38 den 10e+38 e ... ondalıklı olarak */
a = b = c = -27;
x = y = z = 'A';
num = toy = thing = 3.6792;
a = y; /* a nin değeri simdi 65 (karakter A) */
x = b; /* x simdi tuhaf bir sayı olacak */
num = b; /* num simdi -27.00 olacak */
a = toy /* a simdi 3 olacak */
}
gördüğünüz gibi, birkaç integer daha tanımladık Fakat, bundan başka, iki yeni tip daha kattik. “Char” ve “float”.
“Char” tipi, neredeyse integer ile ayni manada. Fakat, sadece 0 ila 255 arasındaki sayıları alabilir, ve genellikle hafızada bir bytelik bir yerde saklanır Bu tip veri, genellikle ya tek bir harfi, veya kelime dizilerini (“string” ler) saklamakta kullanılır.
DATA TIPLERININ KARISTIRILMASI
Bu anda, C nin “int” ve “char” i nasıl kullandığını görmenin tam zamanı C deki “int” tipi ile çalışan çoğu fonksiyonlar, karakter tip veri ile de ayni şekilde çalışabilir, çünkü karakter tipi, bir cins integer’dir.
“char” ve “int” tiplerini neredeyse istediğiniz gibi karıştırmak mümkündür.
Derleyicinin aklı karışmaz, ama sizin karışabilir. Bunun için doğru tip veriyi kullanmakta fayda vardır
FLOAT
İkinci yeni tip veri, “float” tipidir. Kayar nokta da denilen bu tipin sınırları çok geniştir. Çoğu bilgisayarlarda, float tipi 32 bit olarak yani -3.4E+38 den +3.4E+38 e kadardır.
Bunun daha da yetmediği durumlarda “double” da kullanılabilir. Bu ise 64 bit olarak saklanır ve -1.7E+308 to +1.7E+308 arasındaki rakamları taşıyabilir.
YENI VERI TIPLERINI NASIL KULLANALIM?
Bu programın ilk üç satırında, dokuz tane değişkene değer atanıyor.
* Daha önce gördüğümüz gibi, “char” tipi, aslında bir “integer” tipi olduğundan, bir “char” in “int” e çevrilmesinde hiçbir sorun yoktur.
* Fakat, bir integer’i “char” a çevirmek için, bir standart yoktur. Bu nedenle, şayet tamsayi değişkeninin değeri, “char” sahasından büyükse, çıkan sonuç çok şaşırtıcı olabilir.
* üçüncü satırda ise, bir tamsayiyi, “float” a atıyoruz Bu durumda, derleyici, bu ceviriyi bizim için yapar.
* Fakat tersini yapmak ise, biraz daha karışıktır Derleyici şayet varsa, değişkenin ondalık değerini ne yapacağına karar vermek zorundadır Genellikle de, ondalık kesimi gozardi eder.
Bu programın da hiçbir çıktısı yok. Hem zaten karakter ve float tiplerinin nasıl ekrana yazılabileceğini görmedik. Bundan sonraki programa kadar sabır.
COKVERI.C:
================================================================
main()
{
int a; /* basit tamsayi tipi */
long int b; /* uzun tamsayi tipi */
short int c; /* kısa tamsayi tipi */
unsigned int d; /* işaretsiz (+ - siz) tamsayi */
char e; /* karakter tipi */
float f; /* kayar nokta (ondalıklı) tipi */
double g; /* çift 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 (10 tabanlı) */
printf("a = %o\n",a); /* oktal (8 tabanlı) */
printf("a = %x\n",a); /* heksadesimal (16 tabanlı)*/
printf("b = %ld\n",b); /* uzun desimal */
printf("c = %d\n",c); /* kısa desimal */
printf("d = %u\n",d); /* işaretsiz */
printf("e = %c\n",e); /* karakter */
printf("f = %f\n",f); /* kayar nokta */
printf("g = %g\n",g); /* çift hassasiyet k.n. */
printf("\n");
printf("a = %d\n",a); /* basit 'int' çıktı */
printf("a = %7d\n",a); /* 7 uzunlukta bir saha kullan */
printf("a = %-7d\n",a); /* sola dayalı 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 yapışık 12 hane */
}
================================================================
Bu program, C dilinde bulunan bütün standart basit veri tiplerini kapsıyor. Başka tiplerde var, fakat bunlar basit tiplerin bir araya gelmesi ile oluşurlar. Bunlardan daha sonra bahsedeceğiz.
Programı inceleyin. İlk önce basit ‘int’, sonra ‘long int’ ve ‘short int’ görünüyor. ‘unsigned’ tipi, yine integer kadar bir sahada saklanır, fakat artı yada eksi işareti taşımadığından, genellikle sınırı 0 ila 4,294,967,295 arasındadır.
Şayet long, short, yada unsigned deyimi kullanılmışsa, sonuna ‘int’ yazılması gereksizdir.
Daha önce char ve float u görmüştük. Bunlar dışında kalan ‘double’ tipi, ‘float’ a nazaran daha buyuk bir sahada saklanır, ve daha hassas sonuçlar verebilir.
Çoğu derleyicilerin matematik fonksiyonları, float tipini kullanmaz, double tipini kullanır. Bu nedenle verdiğiniz float değeri, size transparan olarak (=size çaktırmadan) double’a çevirir.
PRINTF’IN CEVIRIM KARAKTERLERI
Printf fonksiyonunda kullanılan karakterler şunlardır:
d desimal
o oktal
x heksadesimal
u unsigned (işaretsiz)
c karakter
s string (karakter katarı)
f float (kayar nokta)
Bu harfler, bir yüzde işaretinden sonra kullanırlar. Bu iki harf arasına şunlar ilave edilebilir:
– sahasının içinde sola dayanmış
(n) minimum saha uzunluğunu belirler
. n ile m yi birbirinden ayırır
(m) float tipi için noktadan sonraki hane sayısı
l ‘long’ tipi olduğunu belirtmek için
Bu programı derleyip sonuçlarını inceleyin. Dilediğiniz gibi değiştirerek, sonuçları inceleyin.
MANTIKSAL KARSILASTIRMALAR
KARSILAS.C:
================================================================
main() /* Bir suru karşılaştırma */
{
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 hiçbir şey yapmayacak */
if (b <= c) r = 0.0; /* r = 0.0 olacak */
if (r != s) t = c/2; /* t = 20 olacak */
/* İkinci grup */
if (x = (r != s)) z = 1000; /* x pozitif olacak, ve
z = 1000 olacak */
if (x = y) z = 222; /* bu, x = y, ve z = 222 yapar */
if (x != 0) z = 333; /* z = 333 olacak */
if (x) z = 444; /* z = 444 olacak */
/* üçüncü 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; /* Bir şey değiştiremez! */
/* dördüncü grup */
if (x == x); z = 27.345; /* z daima değer değiştirir */
if (x != x) z = 27.345; /* Hiç bir şey değişmez */
if (x = 0) z = 27.345; /* x = 0 olur, z değişmez!! */
}
================================================================
Karsilas.C isimli programa lütfen bakin. İlk başında dokuz tane
değişken hazırlıyoruz. Daha önce yapmadığımız şekilde, bunları hem
tanımlayıp, hem ilk değerlerini veriyoruz.
gördüğünüz gibi if ile komutlar arasında bir satır bırakmamız gerekmiyor. Programın daha okunabilir olması için arada satır bırakmak şart değildir.
Birinci gruptaki karşılaştırmalar, iki değişkeni karşılaştırdıkları için, en basit olanları. İlk satırda, x in y ye eşit olup olmadığına bakıyoruz. Burada iki eşit işareti yerine (==) tek eşit de kullanılabilirdi, fakat manası değişirdi. (tek eşit işareti ATAMA yapar, karşılaştırma değil)
üçüncü satırda, NOT işaretini görüyorsunuz. Bu ünlem işareti, herhangi bir karşılaştırmanın sonucunu değiştirmek için kullanılabilir.
DAHA ZOR KARŞILAŞTIRMALAR
İkinci grupta yer alan karşılaştırmalar daha zor. İlk önce parantezler arasında tuhaf bir ifade yer alıyor.. Bunu anlamak için C dilindeki ‘EVET’ ve ‘HAYIR’ kavramlarını bilmemiz gerekiyor. C de ‘HAYIR’, 0 değerindedir. ‘EVET’ ise, sıfırdan değişik herhangi bir şeydir. Bir EVET/HAYIR testinin sonucu herhangi bir integer yada karakter değişkenine atanabilir.
İlk örneğe bakin: r!=s deyimi, r nin değeri 0.0 a atandığından, ‘EVET’ bir sonuç verecektir. Bu sonuç, sıfırdan değişik bir rakam, ve herhalde 1 olacaktır. Oluşan bu sonuç, x değişkenine atanır. Şayet x den sonra iki eşit işareti olsa idi (x == (r!=s) gibi) bu durumda bu 1 değeri, x ile karşılaştırılırdı. Fakat tek bir işaret olduğundan, r ile s yi karşılaştırmanın sonucu, x e atanır. Ayrıca bu atama işleminin sonucu da sıfırdan değişik olduğundan, z de 1000 e eşitlenir.
İkinci örnekte ise, x değişkeni, y nin değerini alır, çünkü arada tek eşit işareti vardır. Ayrıca sonuç 11 olduğundan, z de 222 ye eşitlenir.
İkinci grubun üçüncüsünde, x i sıfıra karşılaştırıyoruz. Şayet sonuç ‘EVET’ ise, yani x sıfır değilse, z ye 333 değerini atıyoruz. Bu grubun en son örneğinde ise, Şayet x in değeri sıfır değil ise, z ye 444 atıyoruz.
Yani üçüncü ve Dördüncü örnekler, birbirine eştirler.
üçüncü gruptaki karşılaştırmalar, yeni deyimler sunuyor. Yani ‘AND’ ve ‘OR’ deyimleri. İlk önce 3 değişkene de 77 değerini atıyoruz ki, işlemlere bilinen değerlerle baslayabilelim. Buradaki ilk örnekte, yeni kontrol işaretimiz ‘&&’ i görüyoruz. Bu satirin okunuşu ise:
‘Şayet x, y ye eşit ise, vede x, 77 ye eşit ise, z nin değerini 33 yap.’
Yani, AND operandı için, iki taraftaki işlemlerin EVET (TRUE) sonuç vermesi gereklidir.
Bundan sonraki örnek ise, ‘||’ (OR) işaretini gösteriyor. Bu satır ise, ‘Şayet x, y den buyuk ise, YADA z, 12 den buyuk ise, z nin değerini 22 yap.’ z nin değeri 12 den buyuk olduğu için, x in y den buyuk olup olmaması önemli değildir. çünkü OR operandı için ikisinden birinin EVET olması yeterlidir.
DİKKAT: Birçok kısımdan oluşan bir mantıksal karşılaştırma yaparken, karşılaştırma soldan sağa doğru yapılır, ve sonuç garantilendiğinde, bu satirin islenmesi durur. Mesela, bir AND karşılaştırmasında, şayet AND in sol tarafındaki islem HAYIR (FALSE) sonuç verirse, sağ tarafındaki islem yapılmaz. Yada, bir OR işleminde, sol tarafındaki islem EVET (TRUE) sonuç verirse, işlemin OR dan sonrasına bakılmaz.
OPERANDLARIN İŞLEM SIRASI
Hangi operand ilk önce islenir? Bu konuda birçok kural vardır, ve derleyicinin kitabini bunları uzun uzun anlatır. Fakat, benim tavsiyem, bunlarla uğraşmak yerine, önce islenmesini istediğiniz kısımın çevresine parantez koymanızdır.
üçüncü gruptaki örneklere devam ederek, Dördüncü örnekte, üç tane basit değişkenin birbiri ile AND edildiğini görüyoruz. Ucunun de değerleri sıfırdan değişik olduğundan, sonuç EVET oluyor, ve z nin değeri 11 e eşitlenir.
Bundan sonraki örnekte ise, üç tane atama işlemi görünüyor. Şayet daha önceki örnekleri anladıysanız, bu ‘if’ komutunun dört tane değeri değiştirdiğini görebilirsiniz.
BİR HİLE
Üçüncü grubun en son örneğinde ise, bir hile var. İlk önce, (x==2) nin HAYIR la sonuç verdiğini görüyoruz. Ve daha önce gördüğümüz gibi, C dili, sonuçtan emin oluncaya kadar if komutunu isler. Yani, hepsi AND olduğu için, vede ilk ifade HAYIR (FALSE) olduğu için, işlemi o noktada keser, ve y,z ve r nin değerleri değişmez.
Dördüncü gruptaki örneklerin hiçbiri çalışmaz. Bu grup, başınızı derde sokabilecek komutlardır. ilk örnekte, x == x komutu daima doğrudur, fakat hemen arkasından gelen noktalı virgül yüzünden, bundan sonra gelen z=27.345 komutu ayrı bir komut olarak her zaman işlenir.
ikincisi daha kolay – x daima x e eşit olacağından, denklem daima yanlış olacaktır. Son olarak, x e sıfır değeri atanır, ve parantezin sonucu sıfır olduğundan, z ye atama yapılmaz.
C NİN ÇABUK TARAFLARI
C de 3 tane, bakınca hiçbir şeye benzemeyen, fakat programlarken hız sağlayan kestirme yol vardır. Bu metotlar iyi C programcıları tarafından çok sık kullanıldığından, öğrenmenizde fayda vardır.
KESTIRME.C:
================================================================
main()
{
int x = 0,y = 2,z = 1025;
float a = 0.0,b = 3.14159,c = -37.234;
/* arttırma */
x = x + 1; /* Bu x i bir arttırır */
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 değerini bir azaltır */
y--; /* Bu da.. */
--y; /* Buddah.. */
y = 3;
z = y--; /* z = 3, y = 2 */
z = --y; /* z = 1, y = 1 */
/* aritmetik işlemler */
a = a + 12; /* a ya 12 eklemek */
a += 12; /* 12 daha eklemek.. */
a *= 3.2; /* a yi 3.2 ile çarpmak */
a -= b; /* b yi a dan çıkarmak */
a /= 10.0; /* a yi ona bölmek */
/* şartlı işlemler */
a = (b >= 3.0 ? 2.0 : 10.5 ); /* Bu islem....... */
if (b >= 3.0) /* ve bu işlemler.. */
a = 2.0; /* birbiri ile aynidir */
else /* ve ayni sonucu */
a = 10.5; /* sağlarlar. */
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 değeri bir tane arttırılıyor. İkinci ve üçüncü komutlar da ayni şeyi yaparlar. Yani, iki tane artı işareti, değişkenin değerini bir arttırır. Ayrıca, şayet ++
işareti değişkenin önünde ise, değişken kullanılmadan önce değeri arttırılır, şayet ++ işareti değişkenin arkasında (sağında) ise, kullanıldıktan sonra değeri arttırılır.
Dördüncü komutta ise, y nin değeri, z ye atanır, ve daha sonra da y nin değeri bir arttırılır. Bundan sonraki komutta ise, y nin değeri ilk önce arttırılır, daha sonra bu değer z ye verilir.
İkinci grupta, azaltıcı operatörleri görüyoruz. Ayni arttırıcı operatörler gibi, bu gruptaki örnekler de bir öncekiler ile aynidir.
üçüncü grupta, aritmetik kestirme metodlari görüyoruz. ilk örnekte, a ya12 eklenir. Bunun altındaki satırda ise, tekrar ayni şey yapılır Yani, += operatörü, soldaki değişkene, sağ tarafın sonucunun ekleneceğini belirtir.
Yine ayni şekilde, bu is çarpma, çıkarma, ve bölme işlemleri için de yapılabilir
Dördüncü grupta ise, a ya, karmaşık bir değerin atandığını görüyoruz Bunun hemen altındaki if… satırları ise, bu tek satır ile es anlamdadır Bu karşılaştırma operatörü, üç parçadan oluşmuştur Bu parçalar birbirinden soru, ve iki nokta işaretleri ile ayrılırlar İlk önce soru işaretinden önceki kısım değerlendirilir, sonuç EVET çıkar ise, soru işaretinden hemen sonraki değer, dondurulur, şayet sonuç HAYIR çıkar ise,
iki nokta işaretinden sonraki değer dondurulur.
Bundan sonra ise, bu karşılaştırma operatörünün c ye atama yapmakta kullanıldığını görüyoruz İlk önce, a ile b nin hangisinin değeri büyükse, o değere c ye atanır, ve ikincide ise, hangisi daha küçük ise, o c ye
atanır
Ödev:
1. Birden on ikiye sayacak bir program yazın. Bu program, sayarken rakamları
ve bu rakamların karelerini ekrana yazsın
1 1
2 4
3 9
gibi..
2. Birden on ikiye sayan programı biraz değiştirerek , sayımı yazan, ve 1 in
inversini, beş haneli alan bir program yazın. Yani:
1 1.00000
2 .50000
3 .33333
4 .25000
gibi..
3. Birden yüze kadar sayan, fakat 32 ila 39 arasındaki değerleri yazan bir
program yazın. Her satıra bir rakam yazılsın..