# Computing Fundamentals & C Programming _ Chapter-5 Operatörler ve İfadeler By [Forgotten Semicolon ](https://paragraph.com/@forgottensemicolon) · 2023-01-20 --- 5.1 GİRİŞ --------- _Operatör_, bilgisayara belirli matematiksel veya mantıksal işlemleri gerçekleştirmesini söyleyen bir semboldür. Operatörler, veri ve değişkenleri işlemek için programlarda kullanılır. Genellikle matematiksel veya mantıksal ifadelerin bir parçasını oluştururlar. C operatörleri birkaç kategoriye ayrılabilir. Bunlar: 1. Aritmetik operatörler 2. İlişkisel operatörler 3. Mantıksal operatörler 4. Atama operatörleri 5. Arttırma ve azaltma operatörleri 6. Koşullu operatörler 7. Bitsel operatörler 8. Özel operatörler Bir ifade, tek bir değere indirgeyen bir operandlar ve operatorler dizisidir. Örneğin, **10 + 15** değeri **25** olan bir ifadedir. Değer, **void** dışında herhangi bir tür olabilir. 5.2 ARİTMETİK OPERATÖRLER ------------------------- C, tüm temel aritmetik operatörleri sağlar. Bunlar aşağıdaki tabloda listelenmiştir. **+, –, \*** ve **/** tüm operatörleri, diğer dillerde olduğu gibi çalışır. Bunlar, C’de izin verilen herhangi bir yerleşik veri türünde çalışabilir. Tekli eksi operatörü, aslında, tek operand’ı –1 ile çarpar. Bu nedenle, önünde eksi işareti olan bir sayının işareti değişir. Tamsayı bölme herhangi bir kesirli kısmı keser. Modul bölme işlemi, bir tamsayı bölümünün kalanını üretir. Aritmetik operatörlerin kullanım örnekleri şunlardır: Burada a ve b değişkenlerdir ve **operand** olarak bilinirler. Modul bölme operatörü **%**, float verilerinde kullanılamaz. C’nin üs alma operatörü olmadığını unutmayın. C’nin eski sürümleri unary plus’ı desteklemez, ancak ANSI C destekler. 5.2.1 Integer Aritmetiği ------------------------ a+b gibi tek bir aritmetik ifadedeki operandların her ikisi de tamsayı olduğunda, ifadeye tamsayı ifadesi ve işleme **_integer aritmetiği_** denir. Tamsayı aritmetiği her zaman bir tamsayı değeri verir. En büyük tamsayı değeri, daha önce belirtildiği gibi makineye bağlıdır. Yukarıdaki örneklerde, **a** ve **b** tamsayı ise **a = 14** ve **b = 4** için aşağıdaki sonuçlara sahibiz: Tamsayı bölme sırasında, her iki operand da aynı işaretliyse, sonuç sıfır olur. Biri negatif ise, kesme yönü uygulamaya bağlıdır. Yani,**6/7** **\= 0** ve **–6/–7 = 0** ancak -6/7 sıfır veya -1 olabilir. (Makineye bağlı) Benzer şekilde modul bölme sırasında sonucun işareti her zaman ilk işlenenin (bölünen) işaretidir. Yani **–14 % 3 = –2, –14 % –3 = –2** ve **14 % –3 = 2** **Örnek**: Aşağıdaki program, belirli bir gün sayısını aylara ve günlere dönüştürmek için tamsayı aritmetiğinin kullanımını göstermektedir. #include int main(){ int months, days; printf("Enter days\n"); scanf("%d", &days); months = days/30; days = days%30; printf("Months = %d Days = %d", months, days); return 0; } months ve days değişkenleri integer olarak tanımlanır. Bu nedenle, **months = days/30;** ifadesi ondalık kısmı keser ve tamsayı kısmını aylara atar. Aynı şekilde, **days = days%30;** ifade bölümün kalan kısmını günlere atar. Böylece verilen gün sayısı eşdeğer ay ve gün sayısına dönüştürülür ve sonuç çıktıda gösterildiği gibi yazdırılır. 5.2.2 Real Aritmetik -------------------- Yalnızca real operand’ları içeren bir aritmetik işleme **_Real aritmetik_** denir. Gerçek bir operand, ondalık veya üstel gösterimde değerler alabilir. float değerleri izin verilen anlamlı basamak sayısına yuvarlandığından, son değer doğru sonucun bir tahminidir. Eğer **x**, **y** ve **z** değişken ise, o zaman şunu elde ederiz: % operatörü real operand’larda kullanılamaz. 5.2.3 Karma mod Aritmetiği -------------------------- Operand’lardan biri real, diğeri integer olduğunda, ifadeye **karma modlu aritmetik (mixed-mode arithmetic)** ifade denir. Operand’lardan herhangi biri real türdeyse, yalnızca real işlem gerçekleştirilir ve sonuç her zaman bir real sayıdır. Böylece **15/10.0 = 1.5** iken buna karşılık **15/10** = 1 **olur.** Karma işlemler hakkında daha fazla bilgi, ifadelerin değerlendirilmesiyle daha sonra tartışılacaktır. 5.3 İLİŞKİLİ OPERATÖRLER ------------------------ Sıklıkla iki niceliği karşılaştırırız ve ilişkilerine göre belirli kararlar alırız. Örneğin, iki kişinin yaşını veya iki öğenin fiyatını vs. karşılaştırabiliriz. Bu karşılaştırmalar ilişkisel operatörler yardımıyla yapılabilir. Daha önce ‘daha az’ anlamına gelen ‘<’ sembolünü kullandık. **a < b** veya **1 < 20** gibi bir ifade, **_ilişkisel ifade (relational operator)_** olarak adlandırılır. İlişkisel bir ifadenin değeri ya birdir ya da sıfırdır. Belirtilen ilişki **1** ise **true**, ilişki **0 ise false’dır. Örneğin** **10 < 20** **true**’dur ancak **20 < 10** **false**’dır. C, toplamda altı ilişkisel operatörü destekler. Bu operatörler ve anlamları aşağıdaki tabloda gösterilmektedir. Basit bir ilişkisel ifade, yalnızca bir ilişkisel operator içerir ve **ae-1 relational operator ae-2** biçimini alır. **ae-1** ve **ae-2** basit sabitler, değişkenler veya bunların kombinasyonu olabilen aritmetik ifadelerdir. Aşağıda verilenler, basit ilişkisel ifadelerin bazı örnekleri verilmiştir: Bir ilişkisel operatörün her iki tarafında da aritmetik ifadeler kullanıldığında, önce aritmetik ifadeler değerlendirilir ve ardından sonuçlar karşılaştırılır. Yani, aritmetik operatorler ilişkisel operatorlere göre daha yüksek önceliğe sahiptir. Çalışan bir programın hareket tarzına karar vermek için **if** ve **while** gibi **karar ifadelerinde (decision statements)**’da ilişkisel ifadeler kullanılır. While ifadesini chapter 3'te zaten kullandık. Karar ifadeleri Chapter 7 ve 8'de ayrıntılı olarak ele alacağız. İlişkisel Operatör Tamamlayıcıları ---------------------------------- Altı ilişkisel operatör arasında, her biri başka bir operatörün tamamlayıcısıdır. Aşağıda gösterildiği gibi tümleyenleri kullanarak _değil (not)_ ve _küçüktür (less than)_ operatörlerini içeren bir ifadeyi basitleştirebiliriz: 5.4 MANTIK OPERATÖRLERİ ----------------------- İlişkisel operatörlere ek olarak, C’de aşağıdaki üç mantıksal operator vardır. Mantıksal operatörler **&&** ve **||** birden fazla koşulu test etmek ve karar vermek istediğimizde kullanılır. örneğin **a > b && x == 10 _İki veya daha fazla ilişkisel ifadeyi birleştiren bu tür bir ifade,_ mantıksal ifade (logical expression) veya _bileşik ilişkisel ifade (compound relational expression)_ olarak adlandırılır. Basit ilişkisel ifadeler gibi, mantıksal bir ifade de aşağıdaki tabloda gösterilen doğruluk tablosuna göre bir veya sıfır değeri verir. Yukarıda verilen mantıksal ifade, yalnızca a** **\> b** doğruysa ve **x == 10** doğruysa doğrudur. Bunlardan biri (veya her ikisi) yanlışsa, ifade yanlıştır. Mantıksal ifadelerin kullanımına ilişkin bazı örnekler şunlardır: 1\. if (age > 55 && salary < 1000) 2. if (number < 0 || number > 100) Karar ifadelerini tartıştığımızda bunlardan daha fazlasını göreceğiz. 5.5 ATAMA OPERATÖRLERİ ---------------------- Atama operatörleri, bir ifadenin sonucunu bir değişkene atamak için kullanılır. Her zamanki atama operatörünü ‘=’ gördük. Ek olarak, C, formun bir dizi “stenografi” atama operatörüne sahiptir. **v op= exp;** v bir değişken olduğunda, **exp** bir ifadedir ve **op** bir C ikili aritmetik operatörüdür. **op=** operatörü, kestirme atama operatörü olarak bilinir. atama **v op= exp;** ifadesi **v = v op (exp);** ifadesine eşit olur. v yalnızca bir kez değerlendirildi. **x += y+1; örneğini düşünün** x = x + (y+1);Kısa yol operatörü **+=**, **“x’e y+1 ekle”** veya **“x’i y+1 ile artır”** anlamına gelir. **y = 2** için yukarıdaki ifade şu hale gelir: **x += 3;** ve bu ifade yürütüldüğünde, x’e 3 eklenir. x’in eski değeri, diyelim ki 5 ise, x’in yeni değeri 8'dir. Yaygın olarak kullanılan kestirme atama işleçlerinden bazıları aşağıdaki tabloda gösterilmektedir. Kısa yol atama işleçlerinin kullanılmasının üç avantajı vardır: 1\. Sol tarafta görünenlerin tekrarlanmasına gerek yoktur ve bu nedenle yazmak daha kolay hale gelir. 2. İfade daha özlü ve okunması daha kolay. 3. İfade daha etkilidir. Gibi biraz daha ilgili bir ifadeyi düşünürsek, bu avantajlar takdir edilebilir. **value(5\*j–2) = value(5\*j–2) + delta;** ifadesi **+=** operatörü yardımıyla **value(5\*j–2) += delta;** şeklinde yazılabilir. Okuması ve anlaması daha kolaydır ve **5\*j–2** ifadesi yalnızca bir kez değerlendirildiğinden daha verimlidir. **Örnek:** Program, 2'den başlayarak bir sayı kareleri dizisi yazdırmaya çalışır. **a \*= a;** ifadesi **a = a\*a;** ile aynı. a’nın geçerli değerini karesiyle değiştirir. a’nın değeri N’ye (=100) eşit veya daha büyük olduğunda while sonlandırılır. Çıktının yalnızca 2, 4 ve 16 olmak üzere üç değer içerdiğini unutmayın. #include #define N 100 #define A 2 int main(){ int a; a = A; while (a < N){ printf("%d\n",a); a *= a; } return 0; } 5.6 ARTIRMA VE AZALTMA OPERATÖRLERİ ----------------------------------- C, genellikle diğer dillerde bulunmayan iki çok kullanışlı operatöre izin verir. **Arttırma ve azaltma (++ ve— –)** operatörleri. ++ operatörü, operand’a 1 eklerken — — operatörü 1'i çıkarır. Her ikisi de tekli operatörlerdir ve aşağıdaki formu alır: **++m; m = m+1**'e eşittir; (veya m += 1;) **\--m; m = m–1**'e eşdeğerdir; (veya m –= 1;) Arttırma ve azaltma ifadelerini **for** ve **while** döngülerinde yoğun olarak kullanırız. **++m** ve **m++** birbirinden bağımsız ifadeler oluşturduklarında aynı anlama gelirken, bir atama ifadesinin sağ tarafındaki ifadelerde kullanıldıklarında farklı davranırlar. Aşağıdakileri örneği inceleyin: Bu durumda y ve m’nin değeri 6 olacaktır. Varsayalım ki yukarıdaki ifadeleri şu şekilde yeniden yazarsak o zaman y’nin değeri 5 ve m = 6 olur. _Bir_ **_ön ek (prefix)_** _operatörü operand’a önce 1 ekler ve ardından sonuç soldaki değişkene atanır. Öte yandan, bir_ **_son ek (postfix)_** _operatörü önce soldaki değişkene değer atar ve ardından operandı artırır._ İndisli değişkenlerde ++ (veya--) kullandığımızda da durum benzerdir. Yani, **a\[i++\] = 10;** ifadesi ifadesine eşittir. ++ ve — Operatörleri için kurallar ---------------------------------- ■ Arttırma ve eksiltme operatörleri tekli operatörlerdir ve operand olarak değişken gerektirirler. Bir ifadede değişkenle birlikte postfix ++ (veya — ) kullanıldığında, ifade önce değişkenin orijinal değeri kullanılarak değerlendirilir ve ardından değişken bir artırılır (veya azaltılır). ■ Bir ifadede ++(veya — ) öneki kullanıldığında, önce değişken artırılır (veya azaltılır) ve ardından ifade, değişkenin yeni değeri kullanılarak değerlendirilir. ■ ++ ve — — operatörleri önceliği ve ilişkilendirilebilirliği, tekli + ve tekli — ile aynıdır. 5.7 ŞARTLI OPERATÖR ------------------- Üçlü operatör çifti **“? :”**, **exp1 ? exp2 : exp3** biçiminde koşullu ifadelerini oluşturmak için C’de mevcuttur. Burada exp1, exp2 ve exp3 ifadelerdir (expression). **? :** Operatörü şu şekilde çalışır: önce exp1 değerlendirilir. Sıfır değilse (true), exp2 ifadesi değerlendirilir ve ifadenin değeri olur. exp1 false ise exp3 değerlendirilir ve değeri ifadenin değeri olur. İfadelerden yalnızca birinin (exp2 veya exp3) değerlendirildiğini unutmayın. Örneğin, aşağıdaki ifadeleri göz önünde bulundurun: Burad öncelikle (a > b) ifadesi değerlendirilir. Burada çıktımız 1 (True) ise a ifadesi değerlendirilir ve çıktımız olur. Burada çıktımız 0 (false) ise b ifadesi değerlendirilir ve çıktımız olur. Bu ifadenin if else biçiminde karşılığı aşağıdaki gibi olur. 5.8 BITWISE OPERATÖRLER ----------------------- C, verilerin bit düzeyinde işlenmesi için **bitsel (Bitwise)** operatörler olarak bilinen özel operatörleri destekleme ayrıcalığına sahiptir. Bu operatörler, bitleri test etmek veya sağa veya sola kaydırmak için kullanılır. Bitwise (bitsel) operatörler, float veya double için uygulanamaz. Aşağıdaki, bitsel operatörleri ve anlamlarını listeler. 5.9 ÖZEL OPERATÖRLER -------------------- C, virgül operatörü, **sizeof** operatörü, **pointer** operatörleri **(& ve \*)** ve **member selection (üye seçme)** operatörleri (. ve –> ) gibi bazı özel operatörleri destekler. Pointer operatörleri chapter 13'te ele alınırken, virgül ve sizeof operatorleri bu bölümde tartışılmaktadır. Bir yapının üyelerini seçmek için kullanılan üye seçme operatörleri chapter 12 ve 13'te ele alınmaktadır. ANSI komitesi, “string-izing” ve “token-pasting” operatörleri (# ve ##) olarak bilinen iki önişlemci (preprocessor) operatörü tanıttı. 5.9.1 Virgül Operatörü ---------------------- Virgül operatörü, ilgili ifadeleri birbirine bağlamak için kullanılabilir. Virgülle bağlantılı bir ifade listesi soldan sağa doğru değerlendirilir ve en sağdaki ifadenin değeri, birleştirilmiş ifadenin değeridir. Örneğin, **value = (x = 10, y = 5, x+y);** ifadesi önce x’e 10 değerini atar, sonra y’ye 5 atar ve son olarak değere 15 (yani 10 + 5) atar. Virgül operatörü, tüm operatörler arasında en düşük önceliğe sahip olduğundan, parantezler gereklidir. Virgül operatörünün bazı uygulamaları şunlardır: **for** döngülerinde: **for ( n = 1, m = 10, n <=m; n++, m++)** **while** döngülerinde: **while (c = getchar( ), c != ‘10’)** Değer alışverişi: **t = x, x = y, y = t;** 5.9.2 sizeof Operatörü ---------------------- **sizeof** bir compile zamanı operatörüdür ve bir operand ile kullanıldığında operandın kapladığı bayt sayısını döndürür. Operand bir değişken, sabit veya veri türü niteleyicisi olabilir. Örnekler: **m = sizeof (sum);** veya **n = sizeof (long int);** veya **k = sizeof (235L);** Sizeof operatörü, normalde boyutları programcı tarafından bilinmediğinde dizilerin ve yapıların uzunluklarını belirlemek için kullanılır. Bir programın yürütülmesi sırasında değişkenlere dinamik olarak bellek alanı tahsis etmek için de kullanılır. **Örnek:** Integer a ve double d değişkenlerinin bayt boyutlarını döndüren basit bir program. #include int main(){ int a = 15; double b = 20; printf("Int a = %d\n", sizeof(a)); printf("Double b = %d", sizeof(b)); return 0; } 5.10 ARİTMETİK İFADELER ----------------------- Bir aritmetik ifade, dilin syntax’ına göre düzenlenmiş değişkenlerin, sabitlerin ve operatörlerin bir kombinasyonudur. Şimdiye kadar ele alınan örneklerde bir takım basit ifadeler kullandık. C, herhangi bir karmaşık matematiksel ifadeyi işleyebilir. C ifadesi örneklerinden bazıları aşağıdaki tabloda gösterilmiştir. C’nin üs alma operatörü olmadığını unutmayın. 5.11 İFADELERİN DEĞERLENDİRİLMESİ --------------------------------- İfadeler, **variable = expression;** biçimde bir atama ifadesi kullanılarak değerlendirilir. **Variable**, herhangi bir geçerli C değişkeni adıdır. **expression** ile karşılaşıldığında, önce ifade değerlendirilir ve sonuç, sol taraftaki değişkenin önceki değerinin yerine geçer. Değerlendirme denenmeden önce ifadede kullanılan tüm değişkenlere değer atanmalıdır. Değerlendirme ifadelerine örnekler: Bir operatörün etrafındaki boşluk isteğe bağlıdır ve yalnızca okunabilirliği artırmak için eklenir. Bu ifadeler bir programda kullanıldığında, ifadelerde kullanılmadan önce a, b, c ve d değişkenleri tanımlanmalıdır. 5.12 ARİTMETİK OPERATÖRLERİN ÖNCELİĞİ ------------------------------------- Parantezsiz bir aritmetik ifade, operatörlerin öncelik kuralları kullanılarak soldan sağa doğru değerlendirilecektir. C’de aritmetik operatörlerin iki farklı öncelik düzeyi vardır: **High priority (\* / %)** (**Low priority + –)** Parantezsiz bir aritmetik ifade, operatörlerin öncelik kuralları kullanılarak soldan sağa doğru değerlendirilecektir. C’de aritmetik operatörlerin iki farklı öncelik düzeyi vardır: **x = a–b/3 + c\*2–1** ifadesinde **a = 9, b = 12 ve c = 3** olduğunda, ifade şöyle olur: **x = 9–12/3 + 3\*2–1** ve aşağıdaki gibi değerlendirilir. İfade Değerlendirme Kuralları ----------------------------- \- Önce soldan sağa parantez içindeki alt ifadeler değerlendirilir.Parantezler iç içe ise değerlendirme en içteki alt ifadeden başlar.- Alt ifadelerin değerlendirilmesinde operatörlerin uygulama sırasının belirlenmesinde öncelik kuralı uygulanır.- İlişkilendirme kuralı, bir alt ifadede aynı öncelik düzeyindeki iki veya daha fazla operatör göründüğünde uygulanır.- Aritmetik ifadeler, öncelik kuralları kullanılarak soldan sağa doğru değerlendirilir.- Parantez kullanıldığında, parantez içindeki ifadeler en yüksek önceliği alır. 5.13 BAZI HESAPLAMA SORUNLARI ----------------------------- İfadeler gerçek değerler içerdiğinde, belirli hesaplama hatalarına karşı korunmak için gerekli önlemlerin alınması önemlidir. Bilgisayarın real sayılar için yaklaşık değerler verdiğini ve bu tür tahminlerden kaynaklanan hataların ciddi sorunlara yol açabileceğini biliyoruz. Örneğin, **a = 1.0/3.0;** ve **b = a \* 3.0;** ifadelerini göz önünde bulundurun. (1.0/3.0)x3.0'ın 1'e eşit olduğunu biliyoruz. Ancak b’nin bir programda hesaplanan değerinin 1 olacağının garantisi yok.Diğer bir problem ise sıfıra bölme işlemidir. Çoğu bilgisayarda, bir sayıyı sıfıra bölmeye yönelik herhangi bir girişim, programın anormal şekilde sonlandırılmasına neden olur. Bazı durumlarda böyle bir ayrım anlamsız sonuçlar doğurabilir. Sıfır değeri alması muhtemel paydayı test etmeye ve sıfıra bölmekten kaçınmaya özen gösterilmelidir.Üçüncü sorun, overflow veya underflow hatalarından kaçınmaktır. operandların doğru türde ve aralıkta olduğunu ve sonucun herhangi bir overflow veya underflow oluşturmayacağını garanti etmek bizim sorumluluğumuzdur. 5.14 İFADELERDE TÜR DÖNÜŞÜMLERİ ------------------------------- 5.14.1 Örtük Tür Dönüşümü ------------------------- C, bir ifadede farklı türlerdeki sabitlerin ve değişkenlerin karıştırılmasına izin verir. C, herhangi bir ara değeri otomatik olarak uygun türe dönüştürür, böylece ifade hiçbir önem kaybetmeden değerlendirilebilir. Bu otomatik dönüştürme _örtük tip dönüştürme (implicit type conversion)_ olarak bilinir. Değerlendirme sırasında çok katı tür dönüştürme kurallarına uyar. Operandlar farklı türdeyse, işlem devam etmeden önce ‘alt’ tür otomatik olarak ‘yüksek’ türe dönüştürülür. Sonuç daha yüksek tiptedir. Tipik bir tip dönüştürme işlemi, aşağıdaki şekilde gösterilmektedir. Aşağıda verilenler, ifadeleri değerlendirirken uygulanan kuralların sırasıdır. Tüm **short** ve **char** otomatik olarak **int**’e dönüştürülür; o zaman 1\. Operand’lardan biri **long double** ise, diğeri **long double**’a dönüştürülür ve sonuç **long double** olur; 2. Aksi takdirde, operandlardan biri **double** ise diğeri **double**’a dönüştürülür ve sonuç **double** olur; **3.** Aksi takdirde, operandlardan biri **float** ise, diğeri **float** duruma dönüştürülür ve sonuç **float** olur; **4.** Aksi takdirde, operandlardan biri **unsigned long** **int** ise, diğeri **unsigned long in**t’e dönüştürülür ve sonuç **unsigned long int** olur; 5. Aksi takdirde, operandlardan biri **long int** ve diğeri **unsigned int** ise, o zaman (**a)** **unsigned int** — **long int**’e dönüştürülebiliyorsa, **unsigned int** operandı bu şekilde dönüştürülür ve sonuç **long int** olur; **(b)** aksi takdirde, her iki operand’da de **unsigned long int**’e dönüştürülecek ve sonuç **unsigned long int** olacaktır; **6.** Aksi takdirde, operand’lardan biri **long int** ise, diğeri **long int**’e dönüştürülür ve sonuç **long int** olur; **7.** Aksi takdirde operandlardan biri **unsigned int** ise diğeri **unsigned int**’e çevrilir ve sonuç **unsigned int** olur. Dönüşüm Hiyerarşisi ------------------- C’nin, atamalar dışındaki tüm ifadelerde, aşağıda gösterildiği gibi herhangi bir örtük tür dönüştürmesinin daha küçük boyutlu bir türden daha yüksek boyutlu bir türe yapıldığı kuralını kullandığına dikkat edin: C’nin bazı sürümlerinin tüm float operandları otomatik olarak double kesinliğe dönüştürdüğünü unutmayın.Bir ifadenin nihai sonucu, ona değer atanmadan önce atama işaretinin solundaki değişkenin türüne dönüştürülür. Ancak, son atama sırasında aşağıdaki değişiklikler yapılır. **1.** **float**’tan **int**’e geçiş, kesirli kısmın kesilmesine neden olur. **2\. double**’dan **float**’a, rakamların yuvarlanmasına neden olur. **3.** **long int**’den **int**’e, fazlalık yüksek bitlerin düşmesine neden olur. 5.14.2 Açık Dönüşüm ------------------- C’nin tür dönüştürmeyi otomatik olarak nasıl gerçekleştirdiğini az önce tartıştık. Ancak, tür dönüştürmeyi otomatik dönüştürmeden farklı bir şekilde zorlamak istediğimiz durumlar vardır. Örneğin, bir kasabadaki kadınların erkeklere oranının hesaplanmasını ele alalım. **ratio = female\_number/male\_number female\_number** ve **male\_number** programda integer olarak tanımlandığı için bölme işleminin sonucunun ondalık kısmı kaybolacak ve oran yanlış bir rakam verecektir. Bu problem, gösterildiği gibi değişkenlerden birini yerel olarak float çevirerek çözülebilir: **ratio = (float) female\_number/male\_number** Operatör (**float**), ifadenin değerlendirilmesi amacıyla **female\_number**’ı **float**’a dönüştürür. Ardından, otomatik dönüştürme kuralı kullanılarak, bölme float modunda gerçekleştirilir, böylece sonucun kesirli kısmı korunur. Operatörün (**float**) **female\_number** değişkeninin değerini hiçbir şekilde etkilemediğine dikkat edin. Ayrıca **female\_number** türü programın diğer bölümlerinde **int** olarak kalmaktadır. Böyle bir yerel dönüştürme işlemi, **açık dönüştürme (explicit conversion)** veya bir _değer atama (casting a value)_ olarak bilinir. Bir atamanın genel biçimi şu şekildedir: **(type-name) expression**, burada **type-name**, standart C veri türlerinden biridir. **expression** bir sabit, değişken veya bir ifade olabilir.bazı cast örnekleri aşağıdaki tabloda gösterilmektedir. Casting, belirli bir değeri yuvarlamak için kullanılabilir. **x = (int) (y+0.5);** ifadesini göz önünde bulundurun: **y = 27.6** ise, **y+0.5 = 28.1**'dir ve dönüşümde sonuç 28 olur, yani x’e atanan değer. 5.15 OPERATÖR ÖNCESİ VE İLİŞKİLENDİRİLEBİLİRLİK ----------------------------------------------- Daha önce bahsedildiği gibi, C’deki her operatörün kendisiyle ilişkilendirilmiş bir önceliği vardır. Bu öncelik, birden fazla operatör içeren bir ifadenin nasıl değerlendirileceğini belirlemek için kullanılır. Farklı öncelik seviyeleri vardır ve bir operatör bu seviyelerden birine ait olabilir. Daha yüksek öncelik seviyesindeki operatörler ilk olarak değerlendirilir. Aynı önceliğe sahip operatörler, seviyeye göre “soldan sağa” veya “sağdan sola” değerlendirilir. Bu, bir operatörün ilişkilendirilebilirlik özelliği olarak bilinir. Tablo 5.8 operatörlerin tam listesini, öncelik düzeylerini ve birliktelik kurallarını sağlar. Gruplar azalan öncelik sırasına göre listelenir. Derece 1, en yüksek öncelik seviyesini ve 15 en düşük önceliği gösterir. Liste, henüz ele almadığımız operatörleri de içerir. Operatörlerin öncelik sırasını ve ilişkilendirilebilirliğini dikkatlice not etmek çok önemlidir. **if (x == 10 + 15 && y < 10)** koşullu ifadeyi göz önünde bulundurun. Öncelik kuralları, **toplama (addition)** operatörünün mantıksal operatoründen (&&) ve ilişki operatöründen ( == ve < ) daha yüksek önceliğe sahip olduğunu söyler. Bu nedenle, önce 10 ve 15'in toplanması yapılır. Bu şuna eşdeğerdir: **if (x == 25 && y < 10** Bir sonraki adım, x’in 25'e eşit olup olmadığını ve y’nin 10'dan küçük olup olmadığını belirlemektir. x için 20 ve y için 5 değerini alırsak, o zaman **x == 25 is FALSE** **(0)** ve **y < 10 is TRUE (1)** < operatörü == ile karşılaştırıldığında daha yüksek önceliğe sahip olduğundan, önce y < 10 test edilir ve ardından x == 25 test edilir. Sonunda şunu elde ederiz: if (FALSE && TRUE) Koşullardan biri FALSE olduğundan, karmaşık koşul FALSE olur. Öncelik ve İlişkilendirme Kuralları ----------------------------------- \- Öncelik kuralları, farklı operatörlerin uygulanma sırasına karar verir.- İlişkilendirme kuralı, aynı düzey operatörünün birden çok oluşumunun uygulanma sırasına karar verir. 5.15.1 Matematiksel Fonksiyonlar -------------------------------- Gerçek hayat problemlerinin analizinde cos, sqrt, log vb. matematiksel fonksiyonlar sıklıkla kullanılmaktadır. C compilerlar çoğu bu temel matematik işlevlerini destekler. Ancak, daha kapsamlı bir matematik kitaplığına sahip sistemler vardır ve hangi işlevlerin mevcut olduğunu öğrenmek için başvuru kılavuzuna bakılmalıdır. Aşağıdaki tablo bazı standart matematik fonksiyonlarını listeler. **Not: 1.** **x** ve **y** **double** olarak tanımlanmalıdır. **2**. Trigonometrik ve hiperbolik fonksiyonlarda **x** ve **y** radyan cinsindendir. **3.** Tüm operatörler bir **double** döndürür. **4.** C99, bu işlevlerin **float** ve **long double** versiyonlarını eklemiştir. **5.** C99 çok daha fazla matematiksel fonksiyon ekledi. **6.** Ayrıntılar için Appendix “C99 Features”ne bakın. Bölüm 3'te daha önce belirtildiği gibi, bu operatörlerden herhangi birini bir programda kullanmak için programın başına şu satırı eklemeliyiz: **#include ** --- *Originally published on [Forgotten Semicolon ](https://paragraph.com/@forgottensemicolon/computing-fundamentals-c-programming-chapter-5-operat-rler-ve-fadeler)*