C++ nedir nasil kullanilir kim tarafindan çikarilmi&#; tir ve kodlari dev ar&#;iv by_oops
C NEDIR ?
C programlama dili, Dennis Ritchie tarafindan Bell laboratuarlarinda
yaratilmistir. PDP 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 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, degi***likleri 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 degi***likler 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", degi*** 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++ dersleri 2.bölüm
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 %dn",index);
index = 27;
printf("Indexin degeri simdi %dn",index);
index = 10;
printf("Indexin degeri simdi %dn",index);
}
Bu programda ise, ilk defa olarak bir degisken kullaniyoruz. main() ve {
isaretlerine artik alismis ol***isiniz. 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, ila 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
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 kal***idir, 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 progr*** kolay anlasilir ol***idir. 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 kolaylastirirn");
}
ve:
main() /* Program buradan basliyor */ {printf("iyi yazis,"); printf
("programin anlasilmasini kolaylastirirn");}
Odev bence ödev her zaman gereklidir bunlar&#; yapmaya çal&#;&#;&#;n yaparsan&#;z kKEND&#; KEND&#;N&#;ZE az da olsa c++'da ilerlemi&#; olacaks&#;n&#;z)
1. Ekrana kendi isminizi yazacak bir program yazin.
2. Programa ayri satirlarda, iki "printf" satiri daha ekleyerek,
adresinizi ve telefon numaranizi da yazdirin.
c++ dersleri 3.bölüm
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 ata***ar */
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 ata***ar
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 ***ICI 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; /* den ye - tamsayi olarak */
char x,y,z; /* 0 dan e - tamsayi olarak */
float num,toy,thing; /* 10e den 10e+38 e - ondalikli olarak */
a = b = c = ;
x = y = z = 'A';
num = toy = thing = ;
a = y; /* a nin degeri simdi 65 (karakter A) */
x = b; /* x simdi tuhaf bir sayi olacak */
num = b; /* num simdi 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
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 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 kari***tir. 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 = ;
b = ;
c = ;
d = ;
e = 'X';
f = ;
g = ;
printf("a = %dn",a); /* desi*** */
printf("a = %on",a); /* oktal */
printf("a = %xn",a); /* heksadesi*** */
printf("b = %ldn",b); /* uzun desi*** */
printf("c = %dn",c); /* kisa desi*** */
printf("d = %un",d); /* isaretsiz */
printf("e = %cn",e); /* karakter */
printf("f = %fn",f); /* kayar nokta */
printf("g = %fn",g); /* cift hassasiyet k.n */
printf("n");
printf("a = %dn",a); /* basit 'int' cikti */
printf("a = %7dn",a); /* 7 uzunlukta bir saha kullan*/
printf("a = %-7dn",a); /* sola dayali 7 lik saha */
printf("n");
printf("f = %fn",f); /* basit kayan nokta */
printf("f = %12fn",f); /* 12 lik bir saha kullan*/
printf("f = %fn",f); /* noktadan sonra 3 hane */
printf("f = %fn",f); /* noktadan sonra 5 hane */
printf("f = %fn",f); /* sola yapi*** 12 hane */
}
================================================== =
Bu progr*** 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 - 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 desi***
o oktal
x heksadesi***
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 KARSILASTIR***AR
KARSILAS.C:
==================================================
main() /* Bir suru karsilastirma */
{
int x = 11,y = 11,z = 11;
char a = 40,b = 40,c = 40;
float r = ,s = ,t = ;
/* Birinci grup */
if (x == y) z = ; /* z = olacak */
if (x > z) a = 'A'; /* a = 65 olacak */
if (!(x > z)) a = 'B'; /* bu hicbir sey yapmayacak */
if (b <c> y)
Oto Kutu Yapımı
Koxp Koxp,Knight Koxpcuları, ,Patronus Koxp,ChaosKoxp,koxp Knight Koxpcuları
KNİGHT ONLİNE KOXPCULARIN MEKANI
|
| En son konular | » Bir soru!! Cuma Kas. 12, am tarafından dadas » Soenmezii Koxp Cuma Ekim 08, pm tarafından Admin » Moderatör alımlari funduszeue.info Eyl. 18, pm tarafından k0gamer » Koxp Oto HP-MP Yapımı Cuma Eyl. 17, am tarafından Admin » RoGue AtaK YaPıMı Cuma Eyl. 17, am tarafından Admin » Oto Kutu Yapımı Cuma Eyl. 17, am tarafından Admin » Zamanlı Skiller Yapımı Cuma Eyl. 17, am tarafından Admin » Mage Atak Yapımı Cuma Eyl. 17, am tarafından Admin » Tuşsuz Normal Wall Hack Cuma Eyl. 17, am tarafından Admin |
| | | | Yazar | Mesaj |
|---|
Admin
Admin
Mesaj Sayısı : 16
Kayıt tarihi : 17/09/10
| | Konu: Oto Kutu Yapımı Cuma Eyl. 17, am |
| gerekenler 1 checkbox 2 timer check kodu - Kod:
Private Sub Check33_Click()
If CheckValue = 1 Then
UseAutoLoot = 1
TimerEnabled = True
TimerEnabled = False
Else
UseAutoLoot = 0
TimerEnabled = False
TimerEnabled = True
End If
End Sub
guncellersenız guzel bi şekilde çalışır check timerler kendinize gore ayarlayın timerler ( enabledler false interval tm27 = 50 tm28 = 3 ) - Kod:
Private Sub Timer28_Timer()
Dim MsgCount As Long
Dim rc As Long
Dim MessageBuffer As String
Dim pVal As Long
Dim hp As Long
Dim maxhp As Long
Dim fullcode
Dim code
Dim sKey
Dim deger(1 To 20) As String, iza As Long
Dim dger11 As String
MsgCount = 1
Do While MsgCount <> 0
rc = CheckForMessages(MsgCount)
If CBool(rc) And MsgCount > 0 Then
If ReadMessage(MessageBuffer, MsgCount) Then
code = MessageBuffer
fullcode = funduszeue.info(MessageBuffer, "")
funduszeue.info Asc(Left(MessageBuffer, 1))
Select Case Asc(Left(MessageBuffer, 1))
Case 34
End Select
End If
End If
Loop
End Sub
- Kod:
Private Sub Timer27_Timer()
Dim nn As Long
On Error Resume Next
DispatchMailSlot
If UseAutoLoot = 1 Then
'If OpenNextBox = True Then
For nn = 1 To UBound(LootBox)
If LootBox(nn).BoxOpened = False And LootBox(nn).BoxID <> 0 Then
LootBox(nn).OpenTime = GetTickCount
'funduszeue.info "Opening box..(" & LootBox(nn).BoxID & ")"
'OpenBox LootBox(nn).BoxID
LootBox(nn).BoxOpened = True
Exit For
End If
Next
Else
For nn = 1 To UBound(LootBox)
If LootBox(nn).BoxOpened = True And LootBox(nn).BoxID <> 0 Then
If (LootBox(nn).OpenTime + ) < GetTickCount Then
LootBox(nn).BoxID = 0
'funduszeue.info "Removing box.."
' OpenNextBox = True
Exit For
End If
End If
Next
End If
End Sub
Modül Kodları - Kod:
http://funduszeue.info
hook ve normal pointerler güncel deil
başlat butonuna şunları ekliyoruz - Kod:
MSHandle = 0
MsName = "" & Hex(GetTickCount)
MSHandle = EstablishMailSlot(MsName)
If MSHandle = 0 Then End
Handle
HookBul
| |
| | | | | | Oto Kutu Yapımı | |
|
Similar topics | |
|
|
| ' (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 degi*** 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= 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 *** kullanildigindan, ogrenmenizde fayda vardir.
KESTIRME.C:
=================================================
main()
{
int x = 0,y = 2,z = ;
float a = ,b = ,c = ;
/* 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 *= ; /* a yi ile carpmak */
a -= b; /* b yi a dan cikarmak */
a /= ; /* a yi ona bolmek */
/* sartli islemler */
a = (b >= ? : ); /* Bu islem */
if (b >= ) /* ve bu islemler.. */
a = ; /* birbiri ile aynidir */
else /* ve ayni sonucu */
a = ; /* 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, karma*** 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 progr*** 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
2
3
4 gibi..
3. Birden yuze kadar sayan, fakat 32 ila 39 arasindaki degerleri yazan bir
program yazin. Her satira bir rakam yazilsin..
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 basligidirnn");
}
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",rak***karesi);
}
bitis() /* Bitis fonksiyonu tanimlaniyor. */
{
printf("nKarelerin toplami: %d dir..n",toplam);
}
================================================== ==
KARETOPL.C isimli programa bir bakin. Bu progr*** 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
progr*** 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 dirn",x,y);
}
for (x = 0;x <7> 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 progr***
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++ dersleri 5.bölüm
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 (prepr**essor) 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>0) /* sayet isim1 > isim2 ise, 1 dondurur */
strcpy(kari****isim1);
else
strcpy(kari****isim2);
printf("Alfabetik olarak en buyuk isim %s dir.n",kari***);
strcpy(kari****isim1);
strcat(kari****" ");
strcat(kari****isim2);
printf("Iki isim birden %sn",kari***);
}
=================================================
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", "kari***" 'a
kopyalanir, daha sonra "kari***" 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] = * (index + 7);
}
printf("%sn",isim1);
printf("%snn",isim2);
for (index = 0;index < 12;index++)
printf("%5d %5d %fn",index,ivir[index],tuhaf[index]);
}
================================================
Burada, "float" olarak tanimli bir kayar nokta dizisi goruyorsunuz.
Ayrica bu progr*** 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] = %dn",index,matrix[index]);
yapbirsey(matrix); /* fonksiyona gidip, deger degistirme */
for (index = 0;index < 5;index++) /* degismis matrix i yazalim */
printf("Geri donen matrix[%d] = %dn",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] = %dn",i,list);
for (i = 0;i < 20;i++) /* add 10 to all values */
list += 10;
for (i = 0;i < 5;i++) /* print modified matrix */
printf("Sonraki matrix[%d] = %dn",i,list);
}
==================================================
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 degi***likler,
"matrix" degerlerini de degistirmis.
Dizilerin, nor*** 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[j] = i * j; /* Bu bir carpim tablosudur */
for (i = 0;i < 25;i++)
for (j = 0;j < 12;j++)
dev[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]] = ; /* bu, buyuk[5][5] = ; demek */
for (i = 0;i < 8;i++) {
for (j = 0;j < 8;j++)
printf("%5d ",buyuk[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] = ;" dir.
ODEVLER
1. Herbiri yakla*** 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 = %4dn",index,dizi1[index],dizi2[index],
diziler[index]);
c++ dersleri 7.bölüm
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 degi***lik yapalim */
printf("Degistikten sonra ise %d %d %dn",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[],index;
strcpy(katar,"Bu bir karakter kataridir.");
bir = katar[0]; /* bir ve iki ayni degeri tasirlar */
iki = *katar;
printf("Ilk cikti %c %cn",bir,iki);
bir = katar[8]; /* bir ve iki ayni degeri tasirlar */
iki = *(katar+;
printf("Ikinci cikti %c %cn",bir,iki);
orada = katar+10; /* katar+10 ve katar[10] aynidir. */
printf("Ucuncu cikti %cn",katar[10]);
printf("Dorduncu cikti %cn",*orada);
for (index = 0;index < ;index++)
list[index] = index + ;
pt = list + 27;
printf("Besinci cikti %dn",list[27]);
printf("Altinci cikti %dn",*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, satirda "katar" in 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, den a kadar degerler verilir. Daha
sonra, 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,el***ar;
cevizler = ;
el***ar = ;
printf("Baslangic degerleri %d %dn",cevizler,el***ar);
/* "degistir" i cagirinca, */
degistir(cevizler,&el***ar); /* cevizlerin DEGERI ve, */
/* el***arin adresini geciriyoruz */
printf("Bitis degerleri ise, %d %d dir..n",cevizler,el***ar);
}
degistir(kuru_yemis,meyvalar) /* kuru_yemis tamsayidir */
int kuru_yemis,*meyvalar; /* meyvalar bir tamsayi pointer'idir */
{
printf("Degerler %d %dn",kuru_yemis,*meyvalar);
kuru_yemis = ;
*meyvalar = ;
printf("Sonraki degerler %d %dn",kuru_yemis,*meyvalar);
}
=================================================
Burada, iki tane tamsayi degiskeni (pointer degil) tanimliyoruz:
"cevizler" ve "el***ar". Once bunlara birer deger atiyoruz, ve "degistir"
isimli fonksiyonu cagiriyoruz. Cagirirken, "cevizler" in degeri (), ve
"el***ar" 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 "el***ar" 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.
"el***ar" in degerinin degismesi ise, yine fonksiyona "el***ar"
degiskeninin adresinin bir kopyasi gecirildigi halde, bu adres ana
programdaki "el***ar" a karsilik geldigi icin, fonksiyonda bu adresteki
degeri degistirir degistirmez, "el***ar" 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
HacKO v4 Koxp Source Kodlar&#; Hacko v4 Koxpu biliyor olmal&#;s&#;n&#;z di&#;er ad&#; KOhack lerde felan vard&#; o Koxpun sourcesini yay&#;nl&#;yorum. bende de&#;i&#;tirip y&#;ld&#;r&#;m Koxp diye felan yay&#;nlam&#;&#;t&#;m.
Not : HacKO Koxp Visual C# Dilinde Yaz&#;lm&#;&#;t&#;r. Visual Basic &#;le aç&#;lmaz.
Visual Studio 'in indirme linklerini isterseniz konunun alt&#;ndan belirtin.
HacKO v4 Koxp Source Kodlar&#;n&#; Buradan indiriniz.
Web Hosting - Dedicated Server
Rar &#;ifresi: benjaminlines
Kullan&#;m:
Knight Online giriniz.
Tamamen Login olduktan sonra HacKO'yu Çal&#;&#;t&#;r&#;n&#;z.
Ba&#;lat tu&#;una bas&#;n&#;z.
Genel Sekmesi:
H&#;z Hack : Light Feet veya Swift seçerseniz DC olabilirsiniz.
Lupin & Duvar Hack : Anlatmaya gerek yok heralde ?
"Ba&#;lat - Reset" tu&#;u ile exp. hesaplay&#;c&#;s&#;n&#; çal&#;&#;t&#;rabilirsiniz.
Skill Ayarlar&#; Sekmesi:
Kay&#;t: Bu tu&#;a bas&#;n ve bir skill kullan&#;n, program otomatik olarak skill'in IDsini kaydeder. Önemli : Bunu yaparken di&#;er kullan&#;c&#;lardan uzakta durun. Yoksa program onlar&#;n skillerini kaydediyor.
Zaman : Zamanl&#; skiller buraya girdi&#;iniz sürede bir kullan&#;lacakt&#;r.
Örnek : Wolf için giriyoruz ( = saniye =~ 2dk) NOT : Program ilk wolfu (ya da neyse art&#;k) 2 dk sonra atar, "Atak Ba&#;lat"a t&#;klar t&#;klamaz de&#;il.
Kullanmak istedi&#;iniz pot türlerini girin.
Min. De&#;er : HP ya da MP niz bu de&#;erin alt&#;nda ise, pot kullan&#;lacakt&#;r.
Temizle: Bütün metin kutucuklar&#;n&#; "0" yapar.
Kaydet: Skill ayarlar&#;n&#;z&#; "funduszeue.info" dosyas&#;na kaydeder.
Yükle: "funduszeue.info" dosyas&#;na kaydedilmi&#; skilleri programa yükler.
Atak Sekmesi:
Oto Pot Kullan : Bunu i&#;aretlerseniz, Oto pot aktif hale gelir.
Mana Save : Sadece okçular&#;n tek okluk skillerinde i&#;e yarar.
Oto Kutu : Bildi&#;iniz oto kutu.
Sadece Para Topla : Sadece para toplar.
Mob'a Ko&#; : Yak&#;n dövü&#; ("R" Atak)
Mob'u elle seç : Moblar otomatik olarak seçilmez.
/Town, E&#;er Mob HP > : E&#;er seçilen Mobun can&#; buraya girilen de&#;erden yüksekse, otomatik town at&#;l&#;r. (Can&#;n&#;z %50 den fazla olmal&#;)
Delay : [ x ] [ y ] : x - , y - aras&#; bir de&#;er olmal&#;.Bu de&#;erlerle oynayarak size en uygununu bulabilirsiniz.
Ben de , gayet iyi çal&#;&#;&#;yordu.
Sadece &#;stenilen &#;temleri Toplama
Üstteki listeden toplanmas&#;n&#; istedi&#;iniz itemleri seçerek [ / / ] tu&#;una bas&#;p alt tarafa geçiriyoruz.
Listeden ç&#;karmak istedi&#;imizi seçip [ / / ] tu&#;una bas&#;yoruz.
Listemizi haz&#;rlad&#;ktan sonra "Listeyi &#;&#;le" tu&#;una bas&#;yoruz. (Zaten bu tu&#; güncelleme yapt&#;&#;&#;n&#;z&#; görerek "K&#;rm&#;z&#;" olur.)
Kaydet/Yükle butonlar&#; listeyi kaydetmeye ve daha sonra program&#; kapat&#;p açt&#;&#;&#;m&#;zda geri yüklemeye yar&#;yor.
NOT : E&#;er bir itemin ad&#; 2 kere yaz&#;lm&#;&#;sa 2sini de ekleyin.
Sadece Seçili &#;temleri Topla'y&#; i&#;aretledi&#;iniz anda art&#;k sadece bu itemler toplan&#;r.