İfadeler ve atama: öncelik, yan etki, short-circuit, coercion

İfadeler (expressions) bir programda hesaplamanın temel aracı. Bu konunun sınav karşılığı tek cümle: “What is printed?”. Öncelik, birleşme yönü, değerlendirme sırası, kısa devre ve tip dönüşümü kurallarını bilen biri kodu kafasında çalıştırır. Bilmeyen tahmin eder ve kaybeder.

Altın kurallar:

1. Önce öncelik, sonra birleşme yönü. Aynı seviyedekiler genelde soldan sağa; **, ?: ve = sağdan sola.
2. Java operandları soldan sağa hesaplar. C ve C++ bunu garanti etmez.
3. && ve || gerekmedikçe sağ tarafı hesaplamaz. & ve | her zaman hesaplar.
4. x++ eski değeri, ++x yeni değeri verir.
5. Narrowing dönüşüm Java’da sadece cast ile olur.

Aritmetik ifadeler: öncelik ve birleşme yönü

Operatör önceliği (precedence), farklı operatörlerin hangi sırayla uygulanacağını belirler. Birleşme yönü (associativity), aynı önceliktekilerin sırasını belirler.

System.out.println(8 - 3 * 2 + 10 / 4);   // 8 - 6 + 2
System.out.println(100 / 5 / 2 * 3);      // ((100/5)/2)*3
int a = 4, b = 9;
System.out.println(a > b ? a : b > 5 ? b * 2 : b);

4
30
18

Python’da 2 ** 3 ** 2 = 2 ** 9 = 512 (sağa birleşir) ve -3 ** 2 = -9 (** unary eksiden yüksek). JavaScript’te de 2 ** 3 ** 2 512 verir. APL’de öncelik yoktur, her şey sağdan sola: a + b * c - d = a + (b * (c - d)).

Operand değerlendirme sırası ve side effect

Bir operand değişken ise değeri bellekten okunur; fonksiyon çağrısıysa fonksiyon çalışır. Eğer fonksiyon başka bir operandı değiştiriyorsa sıra önemlidir. Buna functional side effect denir: fonksiyonun bir parametreyi ya da nonlocal (global) bir değişkeni değiştirmesi.

static int g = 4;
static int bump() { g = g + 3; return 2; }

int x = g * bump();   // g önce okunur: 4 * 2
g = 4;
int y = bump() * g;   // bump önce: g = 7, sonra 2 * 7
System.out.println(x + " " + y + " " + g);

8 14 7

Matematikte çarpma değişmeli; burada değil. Java ve C# soldan sağa garanti ettiği için sonuç belli. C ve C++ sırayı belirtmez: aynı kod farklı derleyicilerde farklı sonuç verebilir.

Dil tasarımcısının iki seçeneği var:

1. Functional side effect’i yasakla: fonksiyonlarda iki yönlü parametre ve nonlocal erişim olmasın. Esneklik ölür.
2. Değerlendirme sırasını sabitle (Java’nın yaptığı). Bazı derleyici optimizasyonları (operandları yeniden sıralama) imkânsızlaşır.

Referential transparency: aynı değere sahip iki ifade programda birbirinin yerine konabiliyorsa program referentially transparent’tır. Saf fonksiyonel dillerde (Haskell) değişken ve yan etki olmadığı için bu doğal olarak sağlanır; programı anlamak ve doğrulamak kolaylaşır.

Artırma operatörleri izleme

int c = 3;
int r = c++ * 2 + --c;     // 3*2 + 3
System.out.println(r + " " + c);
int k = 10;
k -= k++ - --k;            // k = 10 - (10 - 10)
System.out.println(k);
int p = 1;
p += p++ + ++p;            // p = 1 + (1 + 3)
System.out.println(p);

9 3
10
5

Tarif: soldan sağa her operand için “şu an değer ne, sonra değişken ne oldu?” diye yaz. Compound assignment’ta (k -= e) soldaki değişkenin değeri e’den önce alınır, bu yüzden e’nin içindeki değişiklikler son atamayla ezilir.

int[] arr = {5, 6, 7};
int idx = 0;
arr[idx++] = arr[idx] + 10;
System.out.println(arr[0] + " " + arr[1] + " " + idx);

16 6 1

Java önce sol taraftaki hedefi (arr[0]) belirler, idx 1 olur; sonra sağ taraf arr[1] + 10 = 16.

Overloaded operatörler

Aynı sembolün birden fazla anlamda kullanılması: + Java’da hem toplama hem String birleştirme. C’de & hem bit düzeyi AND hem adres alma; - hem binary çıkarma hem unary eksi. Kullanıcı tanımlı overloading (C++, C#, Python) okunabilirliği artırabilir (a + b matris toplama) ya da öldürebilir (+ ile çıkarma yapan bir sınıf). Java kullanıcı tanımlı overloading’e izin vermez.

Tip dönüşümleri

• Narrowing: hedef tip kaynağın tüm değerlerini tutamaz (double → int, int → byte). Bilgi kaybı olabilir.
• Widening: hedef tip tüm değerleri (en azından yaklaşık) tutar (int → double). Genelde güvenli; ama int → float büyük sayılarda hassasiyet kaybettirebilir.
• Mixed-mode ifade: farklı tipte operandlar. Dil ya coercion (örtük dönüşüm) yapar ya da hata verir.
• Cast: programcının yazdığı açık dönüşüm.

int n = 5;
System.out.println(n / 2 + n / 2.0);
System.out.println((byte) 200);
System.out.println((int) -7.9 + " " + (int) 7.9);
char ch = 'a'; ch += 2;
System.out.println(ch + " " + ('a' + 2));

4.5
-56
-7 7
c 99

Coercion yazmayı kolaylaştırır ama tip hatalarını gizler (reliability düşer). ML ve F# ifadelerde hiç coercion yapmaz. Java atamada narrowing coercion yapmaz: int g = 3.5; derlenmez.

İlişkisel ve boolean ifadeler

İlişkisel operatörler iki operandı karşılaştırıp boolean üretir. C89’da boolean tip yoktur; 0 false, diğerleri true. Bu yüzden a < b < c C’de geçerlidir ama düşündüğün şeyi yapmaz:

console.log(1 < 2 < 3, 3 > 2 > 1);
console.log("5" == 5, "5" === 5, "5" + 1, "5" - 1);

true false
true false 51 4

3 > 2 > 1: (3 > 2) = true → true > 1 → 1 > 1 → false. JavaScript’in == operatörü coercion yapar, === yapmaz. + String görünce birleştirir, - sayıya çevirir. Java’da 3 > 2 > 1 derlenmez.

Short-circuit evaluation

Sonuç ilk operanddan belli oluyorsa ikincisi hesaplanmaz. false && X her zaman false, true || X her zaman true.

int i = 2, j = 7;
boolean r1 = (i > 5) && (++j > 0);     // atlandı
boolean r2 = (i < 5) || (j++ > 0);     // atlandı
boolean r3 = (i < 5) | (j++ > 100);    // çalıştı: j = 8
boolean r4 = (i > 5) & (++j > 0);      // çalıştı: j = 9
System.out.println(r1 + " " + r2 + " " + r3 + " " + r4 + " " + j);

false true true false 9

Kısa devre sadece hız için değil, doğruluk için de gerekli:

while (k < n && list[k] != key) k++;

k == n olduğunda list[k] dizinin dışında. Kısa devre sayesinde hiç okunmaz. Koşulların sırasını ters yazarsan koruma kaybolur.

Atama biçimleri

my ($x, $y) = (3, 8);
($x, $y) = ($y, $x);
print "$x $y\n";

8 3

TUZAK · C’de if (x = 0). Atama bir ifadedir ve değeri 0’dır. C koşul olarak her aritmetik ifadeyi kabul eder: derlenir, koşul hep false olur ve x sıfırlanır. Java’da koşul boolean olmak zorunda, int boolean’a dönüşmez: derleme hatası. Java burada reliability’yi seçmiş.

Sık yapılan hatalar

System.out.println(8 - 3 * 2 + 10 / 4);

System.out.println(100 / 5 / 2 * 3);

int a = 4, b = 9;
int m = a > b ? a : b > 5 ? b * 2 : b;

int i = 2, j = 7;
boolean r1 = (i > 5) && (++j > 0);
boolean r2 = (i < 5) || (j++ > 0);
boolean r3 = (i < 5) | (j++ > 100);
boolean r4 = (i > 5) & (++j > 0);
System.out.println(r1 + " " + r2 + " " + r3 + " " + r4 + " " + j);

static int g = 4;
static int bump() { g = g + 3; return 2; }
// in main:
int x = g * bump();
g = 4;
int y = bump() * g;
System.out.println(x + " " + y + " " + g);

int c = 3;
int r = c++ * 2 + --c;
System.out.println(r + " " + c);

int[] arr = {5, 6, 7};
int idx = 0;
arr[idx++] = arr[idx] + 10;
System.out.println(arr[0] + " " + arr[1] + " " + idx);

int n = 5;
double d = n / 2 + n / 2.0;

System.out.println((byte) 200);
System.out.println((int) -7.9);

int k = 10;
k -= k++ - --k;
System.out.println(k);

my ($x, $y) = (3, 8);
($x, $y) = ($y, $x);
print "$x $y\n";