VERİ TİPLERİ
Kod:
int sayi;
int sayi=5;
int sayi=-1;
// İnt Veri Tipi Degiskenin Tam Sayıları Tutmasına Yarar.
float sayi;
float sayi=5.3;
float sayi=5.25;
// Float Veri Tipi Değişkenin Ondalıklı Sayıları Tutmasına Yarar.
double sayi;
double sayi=5.24532;
double sayi=4.126437334;
// Double Veri Tipi Değişkenin Yüksek Kesirli Ondalıklı Sayıları Tutmasına Yarar.
char harf;
char harf 'a';
char harf 'B';
// Char Veri Tipi Değişkenin Harf Tutmasına Yarar. 2 Şekil Kullanımı Vardır.Birincisi Sadece Tek Bir Harf Tutmamıza Yarar. Yukarıdaki Gibi
char kelime[5];
char kelime[7] = "webdiyo";
char kelime[10] = "cbuyazilim";
// Char Veri Tipi'nin 2.Kullanımı Dizilerden Yardım Alarak Kelimeleri Değişkende Tutmamıza Yarar.Yukarıdaki GibiOPERATÖRLER
Kod:
sayi = 5;
// Sayi Değişkenine Değer Atama
sayi += 5 || sayi = sayi + 5
// Sayi Değişkenine Değer Ekleme "||" İşareti "veya" Anlamına Gelir.
sayi -= 5 || sayi = sayi - 5
// Sayi Değişkeninden Değer Çıkarma
sayi /= 5 || sayi = sayi / 5
// Sayi Değişkenini Değere Bölme
sayi *= 5 || sayi = sayi * 5
// Sayi Değişkenini Değer İle Çarpma
sayi %= 5 || sayi = sayi % 5
// Sayi Değişkeninin Değere Göre Modunu Alma Veya Sayı Değişkenini Değere Bölüp Kalanını Atama
sayi++ || ++sayi || sayi += 1 || sayi = sayi + 1
// Sayi Değişkenini Bir Arttırma "++sayi" Komutu Kullanıldığı Satırda 1 Arttırma İşlemi Yapar Diğerleri İse 1 Alt Satırda Çalıştırır.
ÖRNEK
///////////////////////////////
#include <stdio.h>
int main()
{
int sayi=1;
printf("%d",++sayi);
// Ekran Çıktısı 2 Olacaktır.
}
#include <stdio.h>
int main()
{
int sayi=1;
printf("%d",sayi++);
// Ekran Çıktısı 1 Olacaktır.
}
///////////////////////////////
// Bir Arttırma Operatörü
sayi-- || --sayi || sayi -= 1 || sayi = sayi - 1
// Sayi Değişkenini Bir Eksiltme "--sayi" Komutu Kullanıldığı Satırda 1 Eksiltme İşlemi Yapar Diğerleri İse 1 Alt Satırda Çalıştırır.
ÖRNEK
///////////////////////////////
#include <stdio.h>
int main()
{
int sayi=1;
printf("%d",--sayi);
// Ekran Çıktısı 0 Olacaktır.
}
#include <stdio.h>
int main()
{
int sayi=1;
printf("%d",sayi--);
// Ekran Çıktısı 1 Olacaktır.
}
///////////////////////////////KARŞILAŞTIRMA OPERATÖRLERİ
Kod:
// Büyüktür Operatörü
x>y
// x Değişkeni ile y Değişkenini Karşılaştırır.Koşul Komutu Olarak Kullanılır.
ÖRNEK
///////////////////////////////
#include <stdio.h>
int main()
{
int x=5,y=4;
if(x>y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL DOĞRU Olacaktır.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int x=4,y=5;
if(x>y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL YANLIŞ Olacaktır.
}
/////////////////////////////////
// Küçüktür Operatörü
x<y
// x Değişkeni ile y Değişkenini Karşılaştırır. Koşul Komutu Olarak Kullanılır.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int x=4,y=5;
if(x<y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL DOĞRU Olacaktır.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int x=5,y=4;
if(x<y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL YANLIŞ Olacaktır.
}
////////////////////////////////
// Eşittir Operatörü
x==y
// x Değişkeni ile y Değişkenini Karşılaştırır. Koşul Komutu Olarak Kullanılır.
ÖRNEK
////////////////////////////////
include <stdio.h>
int main()
{
int x=5,y=5;
if(x==y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL DOĞRU Olacaktır.
}
////////////////////////////////
include <stdio.h>
int main()
{
int x=5,y=4;
if(x==y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");,
}
// Ekran Çıktısı KOŞUL YANLIŞ Olacaktır.
}
////////////////////////////////
// Eşit Değildir Operatörü
x!=y
// x Değişkeni ile y Değişkenini Karşılaştırır.Koşul Komutu Olarak Kullanılır.
ÖRNEK
////////////////////////////////
include <stdio.h>
int main()
{
int x=5,y=4;
if(x!=y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");,
}
// Ekran Çıktısı KOŞUL DOĞRU Olacaktır.
}
////////////////////////////////
include <stdio.h>
int main()
{
int x=5,y=5;
if(x!=y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");,
}
// Ekran Çıktısı KOŞUL YANLIŞ Olacaktır.
}
////////////////////////////////
// Büyüktür Veya Eşittir Operatörü
x>=y
// x Değişkeni ile y Değişkenini Karşılaştırır.Koşul Komutu Olarak Kullanılır.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int x=5,y=5,z=4;
if(x>=y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
if(z>=y)
{
printf("\nKOŞUL DOĞRU");
}
else
{
printf("\nKOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL DOĞRU
KOŞUL YANLIŞ Olacaktır.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int x=5,y=6,z=7;
if(x>=y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
if(z>=y)
{
printf("\nKOŞUL DOĞRU");
}
else
{
printf("\nKOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL YANLIŞ
KOŞUL DOĞRU Olacaktır.
}
////////////////////////////////
// Küçüktür Veya Eşittir Operatörü
x<=y
// x Değişkeni ile y Değişkenini Karşılaştırır.Koşul Komutu Olarak Kullanılır.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int x=5,y=5,z=6;
if(x<=y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
if(z<=y)
{
printf("\nKOŞUL DOĞRU");
}
else
{
printf("\nKOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL DOĞRU
KOŞUL YANLIŞ Olacaktır.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int x=5,y=4,z=3;
if(x<=y)
{
printf("KOŞUL DOĞRU");
}
else
{
printf("KOŞUL YANLIŞ");
}
if(z<=y)
{
printf("\nKOŞUL DOĞRU");
}
else
{
printf("\nKOŞUL YANLIŞ");
}
// Ekran Çıktısı KOŞUL YANLIŞ
KOŞUL DOĞRU Olacaktır.
}
////////////////////////////////KARŞILAŞTIRMA DEYİMLERİ
Kod:
// if() Deyimi
if(koşul)
{
KOMUTLAR...
}
// Koşula Göre İşleve Geçer Koşul Doğru İse "{" ile "}" Parantezleri Arasında Bulunan Komutları Çalıştırır.Koşul Yanlış İse Çalıştırmaz.
// if()-else Deyimleri
if(koşul)
{
KOMUTLAR...
}
else
{
KOMUTLAR...
}
// Koşula Göre İşleve Geçer Koşul Doğru İse if(koşul)'den Sonra Gelen "{" ile "}" Parantezleri Arasında Bulunan Komutları Çalıştırır.else "{" "}" Parantezleri Arası Çalışmaz.
// Koşul Yanlış İse else'den Sonra Gelen "{" ile "}" Parantezleri Arasında Bulunan Komutları Çalıştırır.
// if()-else if() Deyimleri
if(koşul 1)
{
KOMUTLAR1...
}
else if(koşul 2)
{
KOMUTLAR2...
}
else if(koşul n)
{
KOMUTLARN...
}
// Koşula Göre İşleve Geçer Koşul 1 Doğru İse if(koşul 1)'den Sonra Gelen "{" ile "}" Parantezleri Arasında Bulunan Komutları Çalıştırır.else if(koşul n)'e Kadar Olan Kısımlar Çalışmaz.
// Koşulların Hepsi Yanlış İse Hiçbir Komut Çalışmaz.
// Kısacası İlk Doğru Bulduğu Koşul Neyse Sadece O Kısım Çalışır.Ordan Sonra Gelen Koşullar Doğru Olsa Bile Çalışmaz.Bunun Sebebi eğer-aksi halde olmasından kaynaklanır.
// Basit Dilde Anlatılırsa Eğer Koşul 1 Doğru İse Çalıştır.Aksi Halde (Yani Koşul 1 Doğru Değilse) Eğer Koşul 2 Doğru İse Çalıştır Kısmına Geçer.SWITCH - CASE FONKSİYONU
Kod:
switch(ifade)-case deger: Fonksiyonu
// Belirtilen İfadeye Göre Değişen Karar Verme Deyimidir.Çok Fazla if-else Kullanılan Yerlerde Kolaylık Sağlar.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int secenek;
scanf("%d",&secenek);
switch(secenek)
{
case 1 : Komutlar1;break;
case 2 : Komutlar2;break;
case N : KomutlarN;break;
}
}
////////////////////////////////
// Kullanıcı 1'den N'e Kadar Olan Herhangi Bir Değer Girdiğinde O Değerle İlgili Olan Case'nin Karşısındaki Kodlar Çalışacaktır.
// Eğer Caselerin Sonuna break; Komutunu Koymazsanız Çalıştırılan Caseden Sonra N'e Kadar Olan Tüm Case'ler Çalışacaktır.DÖNGÜLER
Kod:
// while() Döngüsü
while(koşul)
{
KOMUTLAR...
}
// Bu Döngümüzde Belirlediğimiz Koşul Doğru Olduğu Sürece Bu Döngü Komutları Tekrar Tekrar Çalıştırmaya Devam Eder.
// do-while() Döngüsü
do
{
KOMUTLAR...
}while(koşul);
// Bu Döngümüz Önce 1 Kere Çalıştırılır. Çalıştıktan Sonra Koşul Doğru Olduğu Sürece Tekrar Tekrar Çalışmaya Devam Eder.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int x=0;
while(x!=5)
{
x++;
printf("*");
}
// Ekran Çıktısı ***** Olacaktır.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int x=0;
do{
x++;
printf("*");
}while(x!=1);
// Ekran Çıktısı * Olacaktır.
}
////////////////////////////////
// for() Döngüsü
for(ifade;koşul;artış miktarı)
{
Komutlar;
}
// Bu Döngümüz Sayac Bitesiye Kadar Çalıştırılır.
// İfade = Döngü Sayacının Başlangıç Değeri
// Koşul = Döngü Sayacının Bitiş Değeri
// Artış Miktarı = Koşul Doğru Olduğu Sürece Sayacın Değerindeki Artış Miktarı
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int i;
for(i=0;i<10;i++)
{
printf("*");
}
// Ekran Çıktısı ********** Olacaktır.
}
////////////////////////////////
// İç İçe For Örnekleri
////////////////////////////////
#include <stdio.h>
int main()
{
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("*");
}
printf("webdiyo");
}
// Ekran Çıktısı ***webdiyo***webdiyo Olacaktır.
}
////////////////////////////////BREAK - CONTINUE
Kod:
// Break Deyimi
break;
// Bu Deyim Kullanıldıktan Sonra Bulunduğu Döngüden Çıkış Yapmasını Sağlar.
// Continue Deyimi
continue;
// Bu Deyim Kullanıldıktan Kendisinden Sonra Bulunan Komutları Atlar Ve Döngüyü Devam Ettirir.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int i;
for(i=0;i<10;i++)
{
printf("%d",i);
if(i == 3)
{
break;
}
}
// Ekran Çıktısı 0123 Olacaktır.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int i;
for(i=0;i<10;i++)
{
if(i == 3)
{
continue;
}
printf("%d",i);
}
// Ekran Çıktısı 012456789 Olacaktır.
}
////////////////////////////////DİZİLER
Kod:
// Tek Boyutlu Dizi
veri_tipi degisken_adi[eleman_sayisi];
// Bu Diziler Bizim Tek Bir Değişkende 1'den Fazla Değer Tutmamıza Tekrar Tekrar Yeni Değişken Oluşturup Amelelik Yapmamızdan Kurtarıyor.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int i,dizi[5] = "1,2,3,4,5";
// Diziler 0.Indisten Başlar Tanımladığınız Eleman Sayısının Bir Eksik Indiste Biter Yukarıdaki Dizimiz 0.Indisten Başlayıp 4.Indiste Bitmektedir.
for(i=0;i<5;i++)
{
printf("%d",dizi[i]);
}
// Ekran Çıktısı 12345 Olacaktır.
}
////////////////////////////////
// Iki Boyutlu Dizi
veri_tipi degisken_adi[eleman_sayisi][eleman_sayisi]
// Bu Diziler Bizim Dizinin Eleman Sayilarini Bölmemize Yarıyor. Yani 80 Eleman Sayili Bir Diziyi 2 Parçaya Bölüyoruz 1.Boyut 10 Elemanlı 2.Boyut 8 Elemanlı Örnekte Daha İyi Anlıcaksınız.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int main()
{
int i,j;
int dizi[5][4] = {{1,2,3,4},
{5,6,7,8},
{9,10,11,12},
{13,14,15,16},
{17,18,19,20}};
for(i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
printf("%d",dizi[i][j]);
}
printf("\n");
}
// Ekran Çıktısı 1234
5678
9101112
13141516
17181920 Olacaktır.
// Yani Çok Boyutlu Dizileri Matematikteki Kümelere Benzetebiliriz Yukarıda Diziyi 4 Elemanlı 5 Alt Kümeye Dönüştürdük.
}
////////////////////////////////
#include <stdio.h>
int main()
{
int i,j;
int dizi[5][4] = {{1,2,3,4},
{5,6,7,8},
{9,10,11,12},
{13,14,15,16},
{17,18,19,20}};
for(i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
printf("%d",dizi[j][i]);
}
printf("\n");
}
// Ekran Çıktısı 1591317
26101418
37111519
48121620 Olacaktır.
// Bu Kodda Ise Her Alt Kümenin Sırasıyla 1-2-3-4. Elemanlarını Yazdırdık.
}
////////////////////////////////FONKSİYONLAR
Kod:
// Normal Fonksiyon
fonksiyon_tipi fonksiyon_adi()
{
KOMUTLAR...
}
// Fonksiyon Tipi return Komutu İle Geri Döndürülecek Değeri Simgeler.
// main() Fonksiyonundan Yada Önceden Yönlendirilmiş Bir Fonksiyondan Bu Fonksiyonu Çağırabilir Ve Bu Fonksiyondaki Komutları Çalıştırabilirsiniz.
// Eğer Çalıştırmak İstediğiniz Fonksiyon Yönlendirme Yaptığınız Satırın Altında Kalıyorsa En Başta Programa Prototipi'ni Tanıtmanız Gereklidir.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int fonksiyon1;int fonksiyon2; // Prototipler
int main()
{
fonksiyon1();
return 0;
}
int fonksiyon1()
{
fonksiyon2();
return 0;
}
int fonksiyon2()
{
printf("webdiyo");
}
// Ekran Çıktısı webdiyo Olacaktır.
// Programda Önce Main Yani Ana Fonksiyondan fonksiyon1'i Çağırdık fonksiyon1 Çalıştı Ve Fonksiyon2'yi Çalıştırdı Ve Ekrana webdiyo Yazdırdı.
////////////////////////////////
// Parametre Alan Fonksiyonlar
fonksiyon_tipi fonksiyon_adi(parametre bildirimleri)
{
KOMUTLAR...
}
// Bu Fonksiyonları Çağırırken Değişken Veya Istediginiz Birşeyi Fonksiyona Yönlendirebilirsiniz Örnekle Daha İyi Anlayacaksınız.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int topla(int x,int y); // Prototip
int main()
{
int a,b;
scanf("%d%d",&a,&b);
printf("%d",topla(a,b));
return 0;
}
int topla(int x,int y)
{
return x+y; // Fonksiyonun Değerini x+y Olacak Şekilde Ayarladık.Yani Fonksiyon Çalışınca Yönlenen x ve y Değişkenlerini Toplayıp Cevap Olarak Gönderecektir.
}
// Ekran Çıktısı Girdiğiniz 2 değerin Toplamı Olacaktır.
////////////////////////////////
// Öz Yinelemeli Fonksiyonlar
// Bu Fonksiyonlar Kendini Durmadan Çağıran Yani Bir Döngüye Sokan Fonksiyonlardır.
ÖRNEK
////////////////////////////////
#include <stdio.h>
int f(int x); // Prototip
int main()
{
int a;
scanf("%d",&a);
printf("%d",f(a));
return 0;
}
int f(int x)
{
static int sonuc=1; // Static Koymamızın Sebebi Fonksiyon Tekrar Tekrar Çağrıldığında sonuc Değişkeni Tekrardan 1 Değeri Almaması İçin
if(x>1) // Eğer x Değişkeni 1'den Büyük İse Fonksiyon Kendini Yinelemeye Devam Edicek.
{
f(x-1);
sonuc *= x;
}
if(x==1) // Eğer x Değişkeni 1 İse Sonucu Döndürücek
{
return sonuc;
}
if(x<1) // Eğer x Değişkeni 0'dan Küçük İse 1 Değerini Döndürücek
{
return sonuc = 1;
}
}
// Ekran Çıktısı Girdiğiniz Değerin Faktoriyeli Olacaktır.
////////////////////////////////
+rep Emek Var
