Up next in 10
Auzef C# Programlama 2024-2025 Vize Soruları,
Auzef Bilgisayar Programcılığı
https://lolonolo.com/2026/03/16/c-programlama-2024-2025-vize-sorulari/
https://lolonolo.com
Show More Show Less View Video Transcript
0:00
Biliyor musunuz? C#arp kodunda bazen
0:02
küçücük hani o gözden kaçan bir işaret
0:05
yazdığınız programın sonucunu baştan
0:07
aşağı değiştirebilir. Peki ama nasıl bu
0:10
gizemli kuralların arkasında ne yatıyor?
0:13
Gelin özellikle yeni başlayanların
0:15
kafasını fena halde karıştıran o meşhur
0:17
C#ARP koymacalarını şöyle bir masaya
0:19
yatıralım. Hem birlikte çözeceğiz hem de
0:22
bu teorik bilgilerin gerçek hayatta ne
0:24
işe yaradığını göreceğiz. Şimdi
0:26
ekrandaki şu kod parçasına bir bakın. Ne
0:29
kadar masum duruyor değil mi? -128
0:31
alıyoruz. Sonra onu bir byt değişkenine
0:33
atıyoruz. E sonra da bir azaltıp ekrana
0:36
yazdırıyoruz. Ne kadar basit değil mi?
0:38
Ama işte bu kodu çalıştırdığınız anda
0:40
konsolda göreceğiniz şey sizi büyük
0:42
ihtimalle şok edecek. İşte bu bölümün
0:44
merkezindeki bulmaca tam olarak bu. Hadi
0:47
dedektif şapkalarımızı takalım ve bu
0:49
beklenmedik sonucun ardındaki sır
0:50
perdesini aralamak için C#arp'ın
0:52
derinliklerine doğru bir yolculuğa
0:54
çıkalım. Peki bu bulmacayı çözmeye
0:57
nereden başlayacağız? İlk ipucumuz veri
0:59
tiplerinin gizemli dünyasında saklı.
1:02
Şöyle düşünün. C#ARP'taki her bir veri
1:04
tipi aslında farklı boyutlarda birer
1:06
kutu gibidir. Bazıları küçücük, bazıları
1:09
devasa ve her kutu farklı miktarda bilgi
1:12
taşıyabilir. İşte biz bu kutuların
1:14
kurallarını anladığımız an kodumuzun
1:16
neden böyle garip davrandığını da
1:17
çözmeye başlayacağız. Bu kutular
1:20
arasında veri aktarma işini en iyi
1:22
bardaklarla su taşıma örneğiyle
1:23
anlatabiliriz. Düşünün küçük bir
1:25
bardaktaki suyu alıp çok daha büyük bir
1:27
bardağa döktünüz. Hiç risk yok değil mi?
1:29
Su taşmaz. İşte C#arp da aynen böyle.
1:33
Küçük kutudaki veriyi büyük kutuya
1:35
atarken sorun yok ben hallederim der ve
1:38
bunu otomatik yapar. Ama ya tam tersini
1:40
yapmaya kalkarsanız kocaman bir
1:42
sürahideki suyu minicik bir bardağa
1:44
sığdırmaya çalıştığınızı hayal edin. Ne
1:46
olur? Su taşar, etraf batar. Yani veri
1:49
kaybı yaşanır. İşte bizim o kod
1:52
parçasında yaşanan şey de tam olarak bu.
1:54
Hah işte o bahsettiğimiz kutuların
1:56
boyutları da tam olarak bunlar. Bir
1:58
bakın int ve long ne kadar devasa byte
2:01
ve say bytesa onların yanında ne kadar
2:03
küçük kalıyor? Ama asıl ilginç olan ne
2:06
biliyor musunuz? Byte ve saybitte. Bakın
2:09
ikisi de aynı boyutta. 8 bit. E o zaman
2:12
fark ne? Fark şu. Byt diyor ki, "Benim
2:15
bütün gücüm pozitif sayılar için 0'dan
2:17
25'e kadar her şeyi saklarım. Say bytesa
2:20
dur bakalım ben o kapasitenin yarısını
2:22
negatif sayılar için ayırıyorum di"
2:23
diyor. İşte bizim o meşhur -128
2:26
problemimizin de anahtarı tam olarak
2:28
burada gizli. Ve işte bu macanın
2:30
çözüldüğü o sihirli an. Negatif sayıları
2:34
saklayamayan o küçücük byt kutusuna biz
2:36
gelip zorla -128 gibi bir değeri
2:39
tıkıştırmaya çalışınca işte o taşma
2:41
dediğimiz olay gerçekleşiyor. En ilginci
2:43
de ne biliyor musunuz? C# size hop ne
2:46
yapıyorsun diye bir hata bile vermiyor.
2:48
Sadece o sayının bitlerini alıyor. Kendi
2:50
bildiği gibi yeniden yorumluyor ve
2:52
ekrana alakasız bambaşka bir pozitif
2:55
sayı basıyor. İşte tam da bu yüzden bir
2:57
programcı olarak hangi kutudan hangi
2:59
kutuya ne koyduğumuzu bilmek zorundayız.
3:02
Yoksa başımız çok ağrır. Hazır
3:04
sayılardan bahsetmişken size Gşarp'ın
3:06
küçük bir sürprizini daha göstereyim.
3:09
Sayıları illaki bildiğimiz onluk
3:11
sistemde yazmak zorunda değiliz. Eğer
3:13
bir gün kodun içinde böyle 0x ile
3:15
başlayan bir şey görürseniz sakın
3:17
şaşırmayın. Bu 16'lık yani hegedesimal
3:20
sistemde sayı yazmanın havalı bir yolu
3:22
sadece. Bu da aslında Garp'ın ne kadar
3:25
güçlü ve esnek bir dil olduğunun küçücük
3:27
bir kanıtı. Öyle değil mi? Tamam.
3:29
Teoriyi yeterince konuştuk sanırım.
3:31
Biraz da pratiğe dönelim. Ne dersiniz?
3:33
Kod yazıyoruz. İyi güzel de
3:35
programımızın bizimle konuşmasını,
3:37
bizden bir şeyler öğrenmesini nasıl
3:39
sağlarız? İşte şimdi programlarımızın
3:41
dış dünyayla iletişim kurduğu o meşhur
3:44
kapıya yani konsola yakından bakacağız.
3:47
Şimdi bu kod satırı özellikle yeni
3:49
başlayanların ilk bakışta aman Allah'ım
3:51
bu ne? Dediği bir satır. Ama durun
3:54
aslında çok basit bir mantığı var.
3:56
C#ARP'ın kafası şöyle çalışıyor. Diyor
3:58
ki birincisi kullanıcı klavyeden ne
4:01
yazarsa yazsın ben bunu bir metin yani
4:04
string olarak okurum. İkincisi bu
4:06
okuduğum metni bir tam sayıya çevirmeye
4:08
çalışırım. Üçüncüsü eğer çevirebilirsem
4:11
bu sayıyı da bana gösterilen kutuya yani
4:14
değişkene atarım. Bu kadar. Oku,
4:16
dönüştür, sakla. Sadece üç basit adım.
4:20
Ekrana bir şeyler yazdırmak tamam da
4:22
bunu böyle şık, düzenli bir şekilde
4:24
nasıl yaparız? Hah işte işin sırrı şu
4:27
süslü parantezlerin içindeki sayılarda
4:29
yatıyor. Bunları değişkenler için
4:31
ayrılmış koltuk numaraları olarak hayal
4:33
edin. 0 numaralı koltuğa her zaman ilk
4:36
değişken oturur. 1 numaralı koltuğa
4:38
ikinci değişken ve bu böyle devam eder.
4:40
Bu sayede çıktının kontrolü tamamen
4:43
sizin elinizde olur. İstediğiniz
4:44
değişkeni istediğiniz yere
4:46
koyabilirsiniz.
4:47
Geldik yine yeni başlayanların sıkça
4:50
düştüğü bir tuzağa. Right mı, right line
4:53
mı? Aslında olay çok basit. Write komutu
4:56
kelimeleri peş peşe aynı satıra dizer.
4:59
İmleç cümlenin sonunda bekler. Ama right
5:01
line ise her seferinde ben işimi
5:04
bitirdim şimdi bir alt satıra geçiyorum
5:06
der. Aradaki tek fark o küçücük line
5:08
kelimesi ama inanın bana programınızın
5:11
çıktısını baştan aşağı değiştirir. Eğer
5:14
C#arp kodunu sihirli büyüler yapmak gibi
5:16
düşünürsek o zaman operatörler de bizim
5:19
sihirli değneklerimiz oluyor. Tamam
5:21
artı, eksi gibi basit olanları hepimiz
5:23
biliyoruz ama şimdi şimdi kodunuza adeta
5:27
süper güçler katacak. Daha az bilinen
5:30
ama bir o kadar da faydalı olan o
5:32
gizemli operatörlerin dünyasına
5:33
dalıyoruz. Hazır mısınız? Evet.
5:36
Programlama dünyasındaki en sinsi
5:37
tuzaklardan birine hoş geldiniz. Sadece
5:40
iki tane artı işaretinin yeri inanın
5:42
bana kodunuzun bütün kaderini
5:44
değiştirebilir. Eğer o işaretler
5:46
değişkenin önündeyse C#ar diyor ki bir
5:48
saniye önce şu değeri bir arttırayım
5:51
sonra ne yapacaksak yaparız. Ama eğer
5:52
işaretler arkasındaysa mantık tamamen
5:55
değişiyor. Ben önce bu değeri mevcut
5:57
haliyle bir kullanayım. İşim bitince
5:58
arttırırım. Bakın bu küçücük fark
6:00
özellikle döngülerim içinde başınıza
6:02
öyle işler açar ki inanamazsınız.
6:05
Kodunuzda sürekli böyle eğer şu doğruysa
6:07
bunu yap değilse şunu yap diye upuzun
6:10
ifels blogları yazmaktan sıkıldınız mı?
6:12
O zaman size harika bir haberim var.
6:14
Tanıştırayım. Üçlü operatör. Kendisi tek
6:17
satırlık if else olarak da bilinir ve
6:19
kodunuzu hem kısacık yapar hem de çok
6:21
daha profesyonel gösterir. Sadece bir
6:24
soru işareti ve bir iki nokta üst
6:25
üsteyle resmen harikalar yaratıyorsunuz.
6:28
İşte bu operatör var ya bu tam bir hayat
6:31
kurtaran. Özellikle bir veri tabanından
6:34
ya da internetten veri çekerken falan
6:36
çok işe yarar. Düşünün bir değişkenin
6:38
boş yani nal gelme ihtimali var. Eğer
6:41
kontrol etmezseniz ne olur? Programınız
6:43
pat diye çöker. İşte bu iki soru
6:45
işareti. Eğer bu değişken boş gelirse
6:48
sen hiç endişe etme. Onun yerine şu
6:51
varsayılan değeri kullan diyor. Bu kadar
6:53
basit. Bu kadar güvenli. Şimdi sizi
6:56
biraz daha derinlere, bilgisayarların
6:58
tam kalbine yani birler ve sıfırların o
7:01
gizemli dünyasına götürmek istiyorum.
7:03
Sakın korkmayın. Kulağa karmaşık
7:05
gelebilir ama aslında çok basit.
7:08
Önümüzde küçük bir bulmaca var. 4
7:10
sayısını alıyoruz ve onun bitlerini yani
7:13
1lerini ve 0ırlarını iki basamak sağa
7:15
doğru ittiriyoruz. Sizce sonuç ne olur?
7:18
Var mı bir tahmin? Ve cevap 1. Evet,
7:21
sadece 1. Bu aslında bize harika bir şey
7:24
gösteriyor. Bu bitsel kaydırma dediğimiz
7:27
olay aslında gizli ve süper hızlı bir
7:29
bölme ya da çarpma işlemi. Kural çok
7:31
basit. Her sağa kaydırma sayıyı ikiye
7:33
bölmek demek. Her sola kaydırma da
7:36
sayıyı 2 ile çarpmak demek. İşte bu
7:38
kadar. Hatırlaması da çok kolay bir
7:40
numara. Peki bir program nasıl karar
7:43
verir? Şunu mu yapsam yoksa bunu mu diye
7:46
nasıl bir yıl izler? İşte bu bölümde bir
7:49
bilgisayar gibi düşünmeyi öğreneceğiz.
7:51
Karışık bir if else bloonun içinde adım
7:53
adım ilerleyerek mantık akışını takip
7:56
edeceğiz. Hadi bakalım tekrar dedektif
7:58
şapkalarına takma zamanı. Kodun izini
8:01
sürelim. Bilgisayar geliyor ve ilk ifı
8:03
ifı kapısını çalıyor. Kapıda bir soru
8:05
var. Y + Z X'e eşit değil mi? Ve aynı
8:09
zamanda Y Z'den büyük mü? Şimdi bu V
8:12
bağlacı çok katıdır. İki şartın da aynı
8:14
anda sağlanmasını ister. Ama bizim
8:16
koşulun ikinci kısmı yanlış. O yüzden
8:18
bilgisayar, "Tamam bu kapı kilitli."
8:19
diyor ve hiç düşünmeden bir sonraki
8:21
kapıya yöneliyor. Ve işte geldik en can
8:25
alıcı noktaya. Tuzak tam burada.
8:27
Bilgisayar ikinci kapıya geliyor ve
8:29
koşulu okumaya başlıyor. Ama o da ne?
8:32
Koşulun içinde bir + y operatörü var. Bu
8:35
ne demekti? Hatırlıyor musunuz? Önce
8:37
artır demekti. Yani y'nin değeri daha
8:40
koşulun sonucu belli olmadan tam o
8:43
kontrol anında 4'ten 5'e fırlıyor. İşte
8:45
bu saniyelik değişim bütün denklemi alt
8:48
üst ediyor ve pat koşul doğruya dönüyor.
8:51
E koşul doğru olunca ne oluyor? Program
8:54
hemen o kapıdan içeri dalıyor. İçindeki
8:56
komutu çalıştırıyor ve ekrana bir artı
8:59
işareti basıyor. Ve işin güzeli ondan
9:02
sonra gelen diğer bütün kapılarını
9:04
tamamen görmezden geliyor. Onların
9:06
yüzüne bile bakmıyor. İşte bu örnek
9:08
operatörlerin koşullar içindeki o gizli
9:10
etkisini anlamanın neden hayati olduğunu
9:13
bize çok net gösteriyor. Tüm bu karmaşık
9:16
mantığı anladık diyelim ama bazen en
9:18
büyük düşmanımız gözümüzden kaçan
9:20
küçücük bir yazım hatası olabiliyor.
9:23
Şimdi sizi saatlerce ekran başında
9:26
nerede hata yaptım diye aramaktan
9:28
kurtaracak C#arp'ın en temel ama bir o
9:31
kadar da hayati olan altın kurallarına
9:33
hızlıca bir bakalım. İşte karşınızda
9:36
Garp'ın asla ama kabul etmeyen pazarlığa
9:39
kapalı dört temel kuralı. Mesela her
9:42
cümlenin sonuna nasıl nokta koyuyorsak
9:44
C#ARP'ta da her komutun sonuna o noktalı
9:46
virgülü koymak zorundayız. Nokta. Bu
9:49
basit kuralları en baştan bir alışkanlık
9:51
haline getirirseniz gelecekte
9:53
yaşayacağınız sayısız baş ağrısından
9:55
kendinizi kurtarmış olursunuz. Benden
9:57
söylemesi. Eğer bu anlattıklarımdan
10:00
aklınızda tek bir şey kalacaksa lütfen o
10:03
da bu olsun. Eğer bir gün kodunuzda
10:05
böyle acayip, beklenmedik, tutarsız
10:08
sonuçlar alıyorsanız, şüphelenmeniz
10:10
gereken ilk yer veri tiplerini birbirine
10:13
zorla dönüştürmeye çalıştığınız
10:14
yerlerdir. Unutmayın, temeller ne kadar
10:17
sağlamsa üzerine inşa edeceğiniz binalar
10:20
da o kadar görkemli olur. Peki tüm bu
10:23
konuştuklarımızdan sonra sizi en çok
10:25
şaşırtan Gşarp kuralı hangisi oldu? Şu
10:28
veri tiplerinin taşması mı yoksa bitleri
10:30
sağa kaydırmanın aslında gizli bir bölme
10:33
işlemi olması mı? Aşağıda yorumlarda
10:35
bizimle mutlaka paylaşın. Unutmayın iyi
10:37
bir geliştirici olmanın en büyük sırrı
10:39
usanmadan, bıkmadan bu neden böyle
10:42
çalışıyor diye sormaktır. Bir sonraki
10:44
bölümde görüşmek üzere. O zamana kadar
10:46
kodlamaya devam.
#Programming
#Education
#Windows & .NET
#Computer Education