cout Komutu :

cout komutu isminden de belli olduğu üzere ‘out’ yani dışarıya, ekrana veriyi gönderir. Göndermekten kastımız ekrana yazması. Bu komutu kullanmak için iostream kütüphanesini kullanmamız gerekmektedir. Hemen örneklerle daha detaylı açıklamalara geçelim ;

#include <iostream>            //cout için gerekli kütüphane.
#include <conio.h>             //getch(); için gerekli kütüphane.
 
using namespace std;           //cout ve cin komutları, iostream kütüphanesindeki
                               //std class'ının içinde yer almaktadır. Dolayısıyla
                               //Bu fonksiyounları kullanırken aslında başına std::
                               //eklememiz gerekmektedir. Bu kod sayesinde eklemeye
                               //gerek kalmaz.
 
int main(void){                //Ana fonksiyonun başlangıcı.
      char isim[] = "ADogan";
      int numara  = 1266;
      cout<<isim;              //isim değişkenini ekrana yazdırdık.
                               //Şuan ekranda sadece ADogan yazmaktadır.
                               //Sonuna ";" koymayı unutmayın.
                               //using namespace std; komutunu kullanmasaydık eğer
                               //std::cout<<isim; şeklinde kullanmamız gerekecekti.
 
      cout<<endl<<isim<<" - "<<numara;
                               //endl (end line) komutu bir satır aşağı atlamaya
                               //yarar. Değişken değil de bir metin yazdırmak
                               //istiyorsak iki çift tırnak ("...") arasına
                               //yazmamız gerekiyor. Ve her farklı türde şeyler 
                               //yazdırmak istediğimizde de gördüğünüz gibi
                               //aralarına << sembollerini ekliyoruz.
 
/*       Şuan ekranda:                                      */
/*              ADogan                                      */
/*              ADogan - 1266                               */
/*       yazmaktadır                                        */
    getch();
    }                          //Ana fonksiyonun bitişi.

cin Komutu :

cin komutu ile kullanıcının klavye ile girdiği veriyi, daha önceden tanımladığımız bir değişkene atama işlemini gerçekleştiririz. Burada dikkat etmemiz hususlar ise şunlar;

• Eğer -örneğin- bir integer değişken tanımladıysak kullanıcıdan integer veri girmesini isteyeceğiz.
• char tipindeki bir değişken için kullanıcının girdiği veride eğer boşluk karakteri varsa, sin komutu sadece boşluktan önceki kısmı değişkene atar. Boşluktan sınrası işleme sokulmaz. Bu tarz verileri almak için gets komutunu kullanmalıyız.
• Komutlar arasında “>>” işaretini kullanmalıyız.

#include <iostream>
#include <conio.h>
 
using namespace std;
 
int main(void){                //Ana fonksiyonun başlangıcı.
    char adi[10], soyadi[10];  //10'ar karakterlik iki tane değişken tanımladık.
    int numara;
 
    cout<<"Lutfen Adinizi, Soyadinizi ve Numaranizi yaziniz :\n";
    //Yukarıdaki işlemde kullanıcının gireceği veri için
    //ekrana bir uyarı mesajı çıkarttık.
 
    cin>>adi>>soyadi>>numara;  //Kullanıcının girdiği verileri sırayla,
                               //belirttiğimiz değişkenlere atadı. Kullanıcı
                               //arasında birer boşluk bırakarak verileri
                               //girebilir ya da her girişten sonra 'enter'
                               //tuşu ile de verileri girebilir.
 
    cout<<adi<<" "<<soyadi<<" - "<<numara;
    //Son olarak ise kullanıcının girdiği verileri atadığımız değişkenleri,
    //yukarıdabelirttiğimiz düzende ekrana yazdırdık.
 
    getch();
    }                          //Ana fonksiyonun bitişi.

Kodumuzu bitirdikten sonra f9 tuşu ile derlediğimizde aşağıdaki gibi bir uygulama ile karşılaşacağız:

Resim 1: cout ve cin komutlarının uygulaması ve aşamalar.

Yukarıda cin komutu sayesinde kullanıcının girdiği ‘ahmet’ verisi ‘adi’ değişkenine, ‘dogan’ verisi ‘soyadi’ değişkenine, ’1266′ verisi ise ‘numara’ değişkenine atandı.

printf Komutu :

printf komutu da cout komutu ile aynı işlemleri yapmaktadır. stdio.h kütüphanesinde bulunmaktadır. Kullanım şekli cout komutundan çok daha farklıdır. Yapısı ise printf(“metin yapısı ve değişken konumları”,değişken listesi); şeklindedir. printf komutunu ile ilgili önce bir örnek yapalım daha sonra dikkat etmemiz gereken noktalara değinelim;

#include <stdio.h> //Kütüphanemizi eklemeyi unutmuyoruz.
#include <conio.h>
 
//printf ve scanf fonksiyonları "için using namespace std;"
//komutunu kullanmaya gerek yoktur.
 
int main(void){                //Ana fonksiyonun başlangıcı.
    char username[10] = "ADogan";
    int number = 1266;
 
    printf("Kullanici Adi : %s, Numara : %d",username,number);
    /*Tırnak işaretleri içerisinde metnimizin nasıl görüneceğini
      belirledik. Tırnak işaretinden sonra ise, tırnak içerisinde
      kullandığımız değişkenleri sırayla tanımladık.*/
 
    getch();
    }                          //Ana fonksiyonun bitişi.

Yukarıdaki kodda kullandığımız %s ve %d, o alanda görünmesini istediğimiz değişkenlerin tiplerini belirtmektedir (bkz:veri tipleri). En sık kullanacağımız veri tipleri aşağıda verilmiştir daha detaylı liste için mutlaka cplusplus.com adresini inceleyin.

• %d : Tamsayı (decimal integer) yani int tipindeki değişkenler için kullanılır.
• %f : Kesirli sayı yani float tipindeki değişkenler için kullanılır.
• %4.2f : Kesirli sayımızın virgülden önce 4, virgülden sonra 2 basamaklı olacak şekilde yuvarlanmasını sağlar.
• %s : Dizi (string) yani char tipindeki değişkenlerin ‘tamamını’ ekrana yazdırmak için kullanılır. (pointerlar konusunda buraya tekrar değineceğiz.)
• %c : Karakter (character) yani char tipindeki değişkenin tek bir karakteri ekrana yazar. Burada, tırnaktan çıkıp değişkenleri tanımladığımız kısımdaki değişkenin kaçıncı karakterini ekrana yazmak istiyorsak onu username[2] şeklinde belirtmeliyiz. Burada karakterlerin sırası 0′dan başlamaktadır.
• %p : İşaretçi adresi (pointer adress) tipindeki değişkenleri yani değişkenin hafızadaki adres bilgisi için kullanılır.

Şimdi bunlarla ilgili birer örnek yapalım.

#include <stdio.h>
#include <conio.h>
 
int main(void){                //Ana fonksiyonun başlangıcı.
    char username[10] = "ADogan";
    int number = 1266;
    float pi = 3.1416;
 
    printf("Numara : %d\n",number);
    printf("Pi Sayisi : %f, Yuvarlanmis Hali: %.2f\n",pi,pi);
    printf("Kullanici Adi : %s, Son Karakteri : %c\n",username,username[5]);
    printf("'number' degiskeninin adresi : %p",&number);
 
    /*  \n : Bir satır aşağı atlar.
        &number : Başındaki & işareti adres sembolüdür. Başına geldiği
        değişkeni artık bir adres bilgisi yapar. %p tipi sadece adres
        yollandığı zaman çalışır.                                        */
 
    getch();
    }                          //Ana fonksiyonun bitişi.

Derlediğiniz zaman ekranda göreceğiniz metin aynen şöyledir:
Numara: 1266
Pi Sayisi : 3.141600, Yuvarlanmis Hali : 3.14
Kullanici Adi : ADogan, Son Karakteri : n
‘number’ degiskeninin adresi : 0028FF2C

Buradaki adres bilgisi number değişkeni o an hafızanın neresine yazıldıysa o hücrenin adresinin 16′lık tabanda yazılmış halidir. Pointerlar dersinde tüm detayı ile adres konusunu ele alacağız.

scanf Komutu :

scanf komutu cin ile aynı mantıktadır. Kullanım şekli printf ile hemen hemen aynıdır. Tek farklı printf komutunda tırnak işaretleri arasına yazdığımız metin biçimi yerine, dışarıdan alınacak verilerin atanacağı değişkenlerin sırası yazılmaktadır. Hemen bi örnek ile uygulamaya geçelim;

#include <stdio.h>
#include <conio.h>
 
int main(void){                //Ana fonksiyonun başlangıcı.
    char username[10];
    int number; float pi;
 
    printf("Numara ve Pi sayisini yazin:\n");
    scanf("%d %f",&number,&pi);
    printf("Numara: %d, Pi: %.2f\n",number,pi);
 
//     scanf fonksiyonunda tırnak işaretleri arasında, alınacak verinin tipini
//   belirttik. Tırnak işaretinden sonra ise gelen verilerin yazılacağı
//   değişkenlerin adreslerini belirttik. Çünkü scanf komutu aldığı veriyi
//   bizim belirttiğimiz adreste bulunan hücrenin içine yazar. Burada direkt
//   olarak değiken ismi kullanamayız. Bu çok önemli bir noktadır.
 
 
    printf("\nKullanici Adinizi yazin:\n");
    scanf("%s",username);
    printf("Kullanici Adi: %s",username);
 
//     scanf fonksiyonu ile dışarıdan bir karakter dizisi yani char tipinde
//   bir veri aldık. Dikkat ederseniz tırnak işaretinden sonraki değişken
//   isminin başına adres sembolu getirmedik. Çünkü char tipindeki
//   değişkenler aslında bir 'dizi'dir. Ve char tipindeki değişkenlerin ismi
//   aslında bir pointer yani bir adres işaretçisidir. Burada username
//   aslında 10 karakterlik harf dizisinin başladığı noktanın adresini tutan
//   bir pointerdır. Dolayısıyla başında & sembolu koymamıza gerek yoktur.
//   Bu dizilere özel bir durumdur. Diziler ve pointerlar konusunda daha iyi
//   anlaşılacaktır.
 
    getch();
    }                          //Ana fonksiyonun bitişi.

Bu kodları derlediğiniz zaman int ve float tipindeki verilerinizi girmenizi isteyecek. Daha sonra bu verilerin atandığı değişkenleri printf komutunda belirttiğimiz şekilde ekrana yazacak. Daha sonra ise char tipinde bir veri isteyecek ve aynı işlemi tekrar yapacak… scanf komutu ise böyle çalışmaktadır.

gets(); Fonksiyonu :

cin ve scanf ile kullanıcıdan istediğimiz char tipindeki veri tek bir kelime olmak zorundır. Örneğin “Steve Jobs” verisini girdiğiniz zaman sadece “Steve” verisini alır ve bizim belirttiğimiz değişkene yazar. İşte bu verinin tamamını bir değişkene atama işlemini gets(); fonksiyonu ile yapabiliyoruz. gets(); fonksiyonu stdio.h kütüphanesinde bulunmaktadır. Örnek ile açıklayalım;

#include <stdio.h>
#include <conio.h>
 
int main(void){                //Ana fonksiyonun başlangıcı.
    char tam_ad[50];
 
    printf("Lutfen Isminizi ve Soyisminizi yazin :\n");
    gets(tam_ad);
    printf("\nTam Adiniz: %s",tam_ad);
 
//     Burada gets(); fonksiyonu parametre olarak tanımladığınız char
//   tipindeki değişkenin adresini alır. Ve girilen verinin tamamını
//   oraya kaydeder.
 
    getch();
    }                          //Ana fonksiyonun bitişi.

Böylece giriş-çıkış işlemşlerinin nasıl yapılacağını da öğrenmiş olduk. Bundan sonraki dersler ise verileri yorumlama işlemleri üzerine olacak.

Aritmetik Deyimler :

Matematiksel işlemleri yaparken kullanacağımız semboller temelde 5 tanedir. Bunlar;

• Toplama (+) : Sağındaki ve solundaki iki bilgiyi uygun şekilde toplar. Örneğin;

  int sayi = 5 + 12;  //5 ve 12 sayılarını toplayıp sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 17dir.
  sayi += 2;          //Bu ifade sayi = sayi + 2; anlamına gelir.
                      //Yani kendi değerini 2 arttırır.
                      //Şuan sayi değişkeninin değeri 19dur.

• Çıkarma (-) : Solundaki ifadeden sağındaki ifadeyi çıkarır. Örneğin;

  int sayi = 12 -5;  //12'den 5 çıkarıp sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 7dir.
  sayi -= 2;          //Bu ifade sayi = sayi - 2; anlamına gelir.
                      //Yani kendi değerini 2 azaltır.
                      //Şuan sayi değişkeninin değeri 0dır.

• Çarpma (*) : Sağındaki ve solundaki iki bilgiyi uygun şekilde çarpar. Örneğin;

  int sayi = 5 * 12;  //5 ve 12 sayılarını çarpıp sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 60dır.
  sayi *= 2;          //Bu ifade sayi = sayi * 2; anlamına gelir.
                      //Yani kendi değerini 2 ile çarpar.
                      //Şuan sayi değişkeninin değeri 120dir.

• Bölme (/) : Solundaki ifadeyi sağındaki ifadeye böler. Bölüm ifadesini gösterir. Örneğin;

  int sayi = 12 / 6;  //12 sayısını 6'ya böldük ve sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 2dir.
  sayi /= 2;          //Bu ifade sayi = sayi / 2; anlamına gelir.
                      //Yani kendi değerini 2'ye böler.
                      //Şuan sayi değişkeninin değeri 1dir.

• Kalan Bulma (%) : En az 4 işlem kadar önemli bir deyimdir. Uygun yerlerde kullanılırsa harika işlere yarar. Sağındaki ifadenin solundaki ifadeye bölümünden kalanını verir. Örneğin;

  int sayi = 12 % 5;  //12 sayısını 5'e bölümünden kalanı bulur.
                      //Ve sayi değişkenine atar.Şuan sayi değişkeninin değeri 2dir.
  sayi %= 2;          //Bu ifade sayi = sayi % 2; anlamına gelir.Yani;
                      //Kendi değerinin 2 ile bölümünden kalanını yeni değeri yapar.
                      //Şuan sayi değişkeninin değeri 0dır.

Arttırma ve Azaltma :

Programımız çalışırken ne yaptığını, nasıl çalıştığını bilmek isteriz. Bunun için de mantıksal sayaçları devreye sokarız. Bir sayacın işleyişini belirmek için ise arttırma ve azaltma işlemlerini sık sık kullanacağız. Örneklere başladığımızda daha iyi göreceğiz. Şimdilik nasıl çalıştığını öğrenmemiz yeterli.

int sayi = 50;
int yeni_sayi;
 
sayi++;         //Bu ifade sayi bilgisini 1 arttırır.
                //Yani sayi = sayi + 1; ile aynı anlamdadır.
                //Şuan sayi değeri 51dir.
 
sayi--;         //Yine yukarıdaki ifade ile aynı mantıkta.
                //Şuan sayi değeri 50dir.
 
yeni_sayi = sayi++;   //Bu işlem aslında şunları yapar;
                      //'önce' sayi değişkenini yeni_sayi değişkenine atar.
                      //'sonra' sayi değişkenini 1 arttırır.
                      //Şuan sayi değişkeni 51, yeni_sayi 50dir.
 
yeni_sayi = ++sayi;   //Bu işlem ise ters sırada ilerler;
                      //'önce' sayi değişkenini 1 arttırır.
                      //'sonra' sayi değişkenini yeni_sayi değişkenine atar.
                      //Şuan sayi değişkeni 52, yeni_sayi 52dir.

Arttırma ve azaltma işlemleri bu şekildedir. Burada dikkat etmemiz gereken şey, bu işlemlerin sadece integer tipindeki ifadelerde yapılmasıdır.

Tip Dönüşümleri :

Matematiksel işlemler yaparken kullandığımız veri tipleri arasındaki ilişki çok önemlidir. C/C++ dillerinde bir int ifadeyle bir float ifadeyi işleme soktuğumuzda sonuç eğer float yani kesirli bir değer çıkıyorsa biz bu ifadeyi integer yani tam sayı olarak tanımlanmış bir değişkene atayamayız. Ya da iki tane integer ifadenin bölümü eğer float bir değer ise işleme soktuğunuz değişken tipleri int olduğu için sonuç yuvarlanıp integer olarak gösterilecektir. İşte böyle durumlarda tip zorlaması dediğimiz işlemleri yapacağız. Birkaç örnek ile bunları açıklayalım;

int sayi1 = 14, sayi2 = 4;
int sonuc;
 
sonuc = sayi1 / sayi2;  //Yani 14/4= 3.5 olacağından sonuç float ifadedir.
                        //sonuc değişkenini int olarak tanımladığımız için
                        //sonuc değişkeninin yeni değeri 3 olacaktır.
                        //Bu sorunu çözmek için sonuc değişkenini float yapmalıyız.
float sonuc;
sonuc = sayi1 / sayi2;  //sonuc değişkenini float yapmamıza rağmen yine 3 olacak.
                        //Çünkü işleme soktuğumuz iki ifade de int.
                        //Sorunu çözmek için tip zorlaması yapmalıyız.
sonuc = (float)sayi1 / (float)sayi2;
sonuc = (float)sayi1 / sayi2;
sonuc = sayi1 / (float)sayi2;    //Bu işlemlerden herhangi biri sorunu çözecektir.
 
sonuc = (float)(sayi1 / sayi2);  //Bu ifade ise yine 3 cevabını verecektir.
                                 //Çünkü işlem önceliğinden dolayı önce bölme işlemi
                                 //yapılıp sonra tip zorlama yapılmış olacak.
                                 //Yani ikinci parantezin içi 3 bulunmuş olacak.
                                 //Ve sonuç 3.0 olacak. Buna da dikkat etmeliyiz.

Math Library (Matematik Kütüphanesi) :

Bazı matematiksel işlemler her ne kadar kağıt kalemle çok kolay olsa da bilgisayara bunu anlatmak satırlarca kod yazmayı gerektirebiliyor. Yine uzman kişiler tarafından hazırlanan en stabil matematiksel fonksiyonlar math.h kütüphanesinde yer almaktadır. Bunların önemli olanlarını yazacak olursak;

• sin(x); cos(x); tan(x); : Trigonometrik fonksiyonlar.
• log(x); log10(x); : e ve 10 tabanlarında logaritma fonksiyonları.
• pow(x,y); : x üzeri y ifadesi.
• sqrt(x); : x ifadesinin karekökü.
• floor(x); ceil(x); : x ifadesinin alt ve üst sınır fonksiyonları.
• fabs(x); : x ifadesinin mutlak değeri.

Gördüğünüz gibi bu ifadeler birer fonksiyondur. Parantez içine yazdığımız x veya y’lere parametre diyoruz (fonksiyonlar konusunda daha detaylı göreceğiz.). Bu parametrelerin tipi önemlidir. Fonksiyonlara gönderdiğiniz paramatre bir integer ise fonksiyonun dışar gönderdiği sonuç da integer olacaktır. Float gönderirsek float, double gönderirsek double… math.h kütüphanesindeki fonksiyonlara göndereceğimiz açı değerleri derece değil radyan cinsinden olmalıdır buna çok dikkat ediniz. (x*PI)/180 yani (x*3.14)/180 ile radyan dönüşümü yapabilirsiniz. Şimdi bunlarla ilgili birkaç örnek yapalım:

#include <math.h>  //Kütüphanemizi import etmeyi unutmuyoruz.
int sonuc;         //
sonuc = pow(2,4);  //pow fonksiyonu 2'nin 4'üncü kuvvetini hesaplayıp
                   //cevabı sonuc değişkenine atayacak.
                   //yani şuan sonuc değişkeninin değer 16 olmuştur.
sonuc = sin( (30*3.14)/180 ); //30 dereceyi radyan cinsine cevirdik ve
                   //sin fonksiyonuna gönderdik.
                   //sonuc değişkeni int olduğu için yeni değeri 0 olacaktır.
                   //sonuc değişkeninin tipini float yaptığımızda
                   //yeni değeri 0.49977 olacaktır.

Math.h kütüphanesindeki diğer fonksiyonlar ve detayları için cplusplus.com adresinden yararlanabilirsiniz.

Kodlama Düzeni :

Programımızı yazarken aşağıdaki gibi bir düzen izlememiz gerekmektedir. Bu alanı lütfen dikkatlice inceleyin;

#include <iostream> /***************************************************/
#include <conio.h>  /*Bu alanda kütüphaneler ve değişmezler tanımlanır.*/
#define PI 3.14     /***************************************************/
 
/**********************************************************************/
/*Bu alanda fonksiyon,class,struct veya global değişkenler tanımlanır.*/
/**********************************************************************/
 
int main(void){         /************************************BAŞLANGIÇ*/
      float sayi;       /* Burası main(ana) fonksiyonumuz.Programmızın*/
                        /* Esas kodlarını burada kullanacağız.        */
      getch();          /**********************************************/
  }                     /****************************************BİTİŞ*/
 
/**********************************************************************/
/*             Bu alanda da fonksiyon tanımlanabilir.                 */
/**********************************************************************/

Yukarda değindiğimiz düzen komutların doğru çalışması içindi. Şimdi de kodların düzenli durması ve anlaşılır olabilmesi için yapılması gerekenlerden bahsedelim.

Yazdığımız bir programın başka birisi tarafından daha net anlaşılması ve geliştirilebilmesi için bazı ufak kurallara uymamız gerekmektedir. Bunlardan en önemlisi daha alt katmanlardaki komutların daha iç sütunlara yazılmasıdır. Hemen bi örnek ile açıklayalım :

#include <stdio.h>
 
int main(void){                  //Katman1 başlangıç.
   int sayi = 1991, i;           //Katman1 içindeki komut.
   for(i=0;i<1991;i++){          //Katman2 başlangıç.
      printf("Sayi : %d\n",sayi);  //Katman2 içindeki komut.
      }                          //Katman2 bitiş.
   }                             //Katman1 bitiş.

Gördüğünüz gibi alt katmanlara girdikçe kodlarımızı daha içerde yazdık. Bu hem kodların anlaşılır olmasını sağlar hem de kodun nerde başlayıp nerede bittiğini daha iyi gösterir. Ayrıca bu tarz kod yazmak global bir kültür olmuştur. Alışkanlık haline getirmeniz sizin için iyi olacaktır.

Derslerin başlangıç kısımlarının önemli olduğu düşündüğüm için bazı noktalarda iyi kavranması için biraz uzatacağım. Dolayısıyla yazıları sabırla, dikkatlice ve uygulayarak takip ederseniz inşallah faydasınız görürsünüz diye umuyorum.

Giriş metni için aklıma başka birşey gelmedi, geldikçe bu kısmı güncellerim zaten ;) yavaş yavaş başlayalım öyleyse…

Derleyici ve Seçimi :

C/C++ kodları, bir derleyici olmadan kodlanamamaktadır. Derleyici dediğimiz şey ise yazdığımız kodları daha alt seviyeli dillere yani bilgisayarın anlayacağı 1 ve 0′lardan oluşan dile çeviren bir arabirimdir. Derleyici kodlarımızı bilgisayarın anlayacağı dile çevirip daha sonra kodları çalıştırabilmemizi sağlar.

Bir çok derleyici mevcut. En sık kullanılan derleyiciler Microsoft Visual Studio, Dev C++, Code::Blocks, NetBeans… derleyicileridir. Bunları inceleyecek olursak;

• Code::Blocks: Kodlama yaparken komutları tahmin etme ve kodları renklendirme olayı ile kod yazma işimizi oldukça kolaylaştıran bir derleyicidir. Fakat ben bunu hiç tavsiye etmiyorum. Özellikle yeni başlayanlar için el alışkanlığı kazanılması çok engelliyor engelliyor. Kodlama sırasında yaptığımız hataları bildirme konusunda da çok eksiği var.
• NetBeans: C/C++ Kodlamasında iyi mi kötü mü bilmiyorum. Çünkü kurulumu esnasında bir çok ekstradan eklentiler istemekte olduğu için pek kullanma fırsatım olmadı. Ama kullananların beğendiğini çok sık duyuyorum.
• Dev C++: Kesinlikle tavsiye ettiğim ve kullandığım bir derleyicidir. Hem çok hafif bir derleyici hem kurulumu kolay hem de kodlama yaparken yaptığınız hatalarda çok iyi yardımcı oluyor. Türkçe dil desteği de mevcut.(“with Mingw/GCC” versiyonunu indirin. Kurulum esnasında kütüphanelerin de yüklenmesini istediğinizi ilgili adımda belirtmeyi unutmayın.)
• Microsoft Visual C++: Bu derleyici ile hiç C/C++ kodlaması yapmadım. Ama Microsoft’un yıllardır geliştirdiği bir derleyici olduğu için başarılı olduğuna eminim. Yalnız çok kasıntı bir program açarken kaparken hakikaten çok canınızı sıkıyor ve lisans probleminden dolayı sıkıntı çekebilirsiniz belki. Ayrıca çok detaylı olduğu için pek tavsiye etmiyorum.

Derleyicinizi kurduktan sonra nasıl kullanılacağı hakkında internetten bilgi edinmeniz işinizi kolaylaştıracaktır. Ben Dev C++ kullanıyorum. Dev C++ derleyicisinin kurulumunu yaparken kütüphaneleri de yüklemeyi unutmayın. Kodlama yaparken yazdığınız programın derlenip çalıştırılması için yapmanız gerekn tek şey f9 tuşuna basmak. Başka birşeye gerek yok.

Kütüphaneler :

Kütüphaneler isminden de anlaşılacağı gibi içinde işimizi kolaylaştıracak bilgiler bulunduran bilgi kaynaklarıdır. Bildiğimiz kütüphanelerden tek farkı içerisinde kitap değil önemli fonksiyonların olmasıdır. Bu fonksiyonlar uzman insanlar tarafından hazırlanmış en stabil yardımcı kodlardır. Bir bilgisayar (işlemci) toplam sadece 3 çeşit işlem yapar; toplama, çıkarma ve kıyaslama. Örneğin bir bölme işlemi nedir? Bölen sayının, bölünen sayı içerisinde kaç defa olduğudur değil mi? Bu da temelinde bir toplama işlemidir aslında. Bunları ilerde örneklerle inceleyeceğiz… İşte bu kütüphaneler de içlerinde öyle kodlar bulunduruyorlar ki o kodlar sayesinde yeri geldiğinde onlarca satırlık kodu tek satırlık bir kod ile halledebilmemizi sağlıyorlar.

Bizim şimdilik kullanacağımız belli başlı kütüphaneler ise şunlar;

• stdio.h: gets, printf, scanf…
• math.h: sqrt, pow, fabs (matematiksel işlemler; kare, karekök gibi)…
• conio.h: getch…
• stdlib.h: rand, srand…
• string.h: strlen…
• iostream.h: cin, cout…
• time.h: time…

Bu kütüphaneleri ve diğer kütüphaneleri daha detayıyla incelemek isterseniz eğer cplusplus.com adresini inceleyebilirsiniz.

Kütüphaneler şu şekilde kullanılır;

#include 
#include

Veri Tipleri :

Bilgisayarın hafızasına yazmak istediğimiz verileri hafızaya yazarken, o verinin cinsini de belirtmemiz gerekmektedir. Çünkü her veri tipi için hafızada farklı büyüklüklerde yer ayrılır. Kaydettiğimiz veriyi tekrar kullanacağımız zaman da ona göre okur.

Bu veri tipleri ise şu şekildedir;

• int : (integer) Tam sayıdan oluşan veriler için kullanılan veri tipidir. Sınır ise +-32768dir. İhtiyaca göre long int veya short int şeklinde de sınırlar değiştirilebilir.
• float : Kesirli sayıdan oluşan veriler için kullanılır.
• double : Çifte duyarlıklı kesirli sayıdan oluşan veriler için kullanılır.
• char : (character) karakterden (simge) oluşan veriler için kullanılır. Fakat burada girilen harfler ASCII kodlamasına göre sıralandırılır ver ona göre bir sıra numarası ile bilgisayar diline çevrilir. Örneğin ‘A’ harfi ASCII kodlamasına göre 65. sırada yer almaktadır. Bizim girdiğimiz A harfini yeri geldiğinde kıyaslama veya kontrol etmek için kullanırken 65 olarak kullanacağız. Uygulamalara geçtiğimizde daha da iyi anlaşılacaktır.
• Bool : Mantıksal değerler yani true false tipindeki veri tipleri için kullanılır.

Standart veri tipleri bu şekildedir… Fakat örneğin bir program yazarken bazen öyle durumlar olur ki elimizde yüzlerce int tipinde veri olur ve bunları kullandıktan sonra bir sorunla karşılaşırız ve bu verilerin tipini float yapmamız gerekebilir. işte bu tarz sorunlarda işimizi kolaylaştırmak için “typedef” komut kullanılmaktadır. typedef komutu ile kendi veri tipimizi oluştururuz.

Kullanımı ise şu şekildedir ( typedef veri_tipi yeni_isim; ) ;

typedef int para_birimi;

Bu kod ile para_birimi diye bir veri tipi oluşturmuş olduk. İleride bir sorunla karşılaştığımızda değerleri tek tek float yapmak yerine yukarıdaki satırdaki int değerini float yapmamız işi çözecektir.

Değişkenler :

C/C++ ve diğer tüm programlama dillerinde değişkenler kullanılmaktadır. Verilerimizi hafızaya yazabilmemiz için bilgisayar bize hafızada bir yer ayırmaktadır. İşte bizim için ayrılan bu alana veya bu alanın ismine biz değişken diyebiliriz. O an tanımladığımız değişken hafızanın neresinde oluşturulduysa o değişken artık o hafıza alanının adıdır. Başka birşey için olağanüstü durumlar dışında kullanamayız.

Değişkenleri şu şekillerde tanımlarız;

int sayi; //int tipinde sayi isimli bir değişken.
float kesirli_sayi; //float tipinde kesirli_sayi isimli bir değişken.
int sayi_bir, sayi_iki, sayi_uc; //int tipinde değişkenleri tek satırda tanımladık.
char isim[10];  //10 karakterlik char tipinde bir karakter değişkeni tanımladık.

Bu değişkenlere başlangıç değerleri de verebiliriz. char tipindeki değişkenler aslında bir dizidir. Bunları diziler konusunda daha detaylı göreceğiz o yüzden üstlerine fazla düşmeyeceğiz şimdilik.

int sayi = 250;
float kesirli_sayi = 15.10;
char isim[] = "ADogan"; //Başlangıç değerleri verirken boyut belirtmesek de olur.

Değişkenlerin tuttukları veriler daha sonradan değiştirilebilir. Ama bu yöntem pek sağlıklı olmaz. Algoritmamızı hazırlarken böyle sorunların çıkmamasına dikkat etmeliyiz.

int sayi = 500; //İlk değer.
..... //diğer kodlar.
sayi= 1259; //Son değer. Artık bu kullanılır.

Değişmezler

Değişkenlerin tuttukları gördüğünüz üzere daha sonrada yeni bir atama ile değiştirilebilmektedir. Fakat değişmezlerde bu böyle değildir. Daha sonrada değiştirilmesini istemediğimiz değişkenleri tanımlarken #define kodunu kullanırız. Kullanım şekli ise şöyledir;

#define PI_SAYISI 3.14 //Sonda ";" ve "=" işaretleri yok.
                       //Değişmez ismi büyük harflerle yazılır.
 
PI_SAYISI = 3;         //Hiçbir etki göstermeyecektir.

Giriş konumuz bu kadar. Kodların içine gömülme vakti yaklaşıyor ;)

Threaded Comments özelliği WordPress’in default teması olan Twentyeleven teması tarafından desteklenmektedir (Resim 1). Fakat Twentyten teması bu özelliği desteklememektedir. Sanıyorum çoğu WordPress Teması halen desteklememekte. Bu özelliğin kullanımı ile ilgili WordPress Codex sayfasında da çok detaylı bir bilgi ben bulamadım. Türkçe kaynak da bulamadım. Hatta ve hatta ‘tam’ anlamıyla açıklayan bir ingilizce kaynak da bulamadım. Farklı kaynaklardan topladığım bilgilerle size Threaded Comments özelliğinin, kendi tasarladığınız temalara nasıl uygulayacağınızı anlatmaya çalışacağım.

Resim 1: WordPress Twentyeleven temasındaki Threaded Comments özelliği.

Uygulama Adımları :

• Threaded Comments özelliğini kullanacağınız şekilde yorumlar alanınızın Html ve Css kodlamasını bitirmek.
• Dashboard üzerinden Threaded Comments Özelliğini aktif hale getirip, seviyesini belirlemek.
• ‘comment-reply’ Scriptini header.php dosyasına import etmek.
• Daha önceden hazırlamış olduğumuz comments.php dosyasında gerekli değişiklikleri yapmak.
• functions.php dosyasına gerekli fonksiyonu yazmak.

Dikkat Edilecek Noktalar :

• Her bir yorumun ve yorum yapma formunun bulunduğu alan sabit bir genişlik değerine sahip olmayacak. Yani % hesabıyla çalışmalısınız çünkü alt kademeye geçtikce yorum alanı daralacak. (Tabi siz bambaşka bir tasarım düşünüyorsanız orası size kalmış.)
• Yorumun tasarımını tamamen kapsayacak bir kapsül içine almalısınız (div, li… gibi en dışarıda bir kapsül ile yorum alanı toplanmış olmalı.)

İlk adımı bitirip Html ve CSS kodlamanızı bitirdiyseniz uygulamaya başlıyalım;

Threaded Comments Özelliğini Aktif Hale Getirmek :

Admin Paneli (wp-admin) / Ayarlar / Tartışma / Kademeli yorumlara ’5′ seviyesine kadar izin ver.
Seçeneğini içaretleyin, seviyeyi kafanıza göre belirleyin ve kaydedin.

‘comment-reply’ Script’ini Import Etmek :

header.php dosyasını açın ve aşağıdaki kodu bulun;

<?php wp_head(); ?>

Ve üst kısmına aşağıdaki kodları ekleyin;

<?php if ( is_singular() ) wp_enqueue_script( 'comment-reply' );?>

Bu kod Tekil Yazılar açıldığında bu Script’i aktif hale getirecek. Siz bu yorumları Özel Sayfalarda da yani page.php formatının açıldığı sayfalarda da aktif hale getirmek istiyorsanız;

<?php if ( is_singular() or is_page() ) wp_enqueue_script( 'comment-reply' );?>

Kodunu kullanın… Tüm sayfalarda aktif olsun isterseniz de;

<?php wp_enqueue_script( 'comment-reply' ); ?>

Kodunu kullanın.

‘comments.php’ Dosyasını Düzenlemek :

comments.php dosyasında, yorumları aşağıdaki fonksiyonu kullanarak çekeceğiz. Bunun dışında hazırladığınız bir yorum şablonu ya da fonksiyonu varsa onu kullanamazsınız. Ama o tarzı yine 4. aşamada hazırlayacağımız fonksiyonda uygulayabilirsiniz… Aşağıdaki kodu comments.php’de uygun yere ekleyelim;

<ol class="commentlist">
    <?php wp_list_comments( array( 'callback' => 'yorum_fonksiyonunun_adi' ) ); ?>
</ol>

Bu fonksiyonun ol tagleri arasında olmasına dikkat edelim. Yoksa sonuç başarılı olmayacaktır… Fonksiyonun içindeki arrayde kullandığımız callback son aşamada functions.php dosyasına yazacağımız yorum fonksiyonunun ismidir. O kısmı düzenlemeyi unutmayın.
wp_list_comments() fonksiyonunun parametreleri ve özelliklerini buradan inceleyebilirsiniz.

Yorum yapma formunu da yine kendi kafamıza göre yazamıyoruz. Bunun için aşağıdaki fonksiyonu kullanacağız. Aşağıdaki kodları, yukarıdaki kodu eklediğiniz yerin altında olacak şekilde uygun yeri bulup ekleyin ve devam edelim;

<?php comment_form(); ?>

comment_form() Fonksiyonu normalde bu haliyle wordpress’in varsayılan yorum formu stilini kullanarak ekler. Fakat bu fonksiyon parametre olarak yine çok yerinde array’ler alıyor ve bu sayede istediğiniz tarzı verebilirsiniz. Bunun için buradaki açıklamaları kullanarak işinizi halledebilirsiniz.

‘functions.php’ Dosyasını Düzenlemek :

İlk olarak functions.php dosyasına aşağıdaki kodları eklemekle başlayalım.

<?php
function yorum_fonksiyonunun_adi( $comment, $args, $depth ) {
    $GLOBALS['comment'] = $comment;
    <li <?php comment_class(); ?> id="li-comment-<?php comment_ID(); ?>">
        <article id="comment-<?php comment_ID(); ?>" class="comment">
        	//Buraya tasatımını yaptığınız yorum kapsülünün kodları gelecek.
        </article>
}
?>

Burada comments.php dosyasında çağırdığımız fonksiyonu tanımladık. comments.php dosyasındaki wp_list_comments() fonksiyonu, bu fonksiyondaki şablon kullanılarak veritabanından yorumları alıp tek tek sıralayacak. Dikkat ettiyseniz li tagini kapatmadık. Çünkü bu fonksiyon li tagini kendisi kapatıyor. Sıralarken ise Resim 2′deki gibi bir listeleme uygulayacak.

Resim 2: Yorumların listelenme şekli.

Sistemin işleyişi bu şekilde… Yorum alanı kapsülünü hazırlarken buradaki fonksiyon örneğindeki kodları kullanabilirsiniz.
Yorum alanına cevaplama linkini eklemek için de aşağıdaki kodu kullanacaksınız;

<?php comment_reply_link(
    array_merge( $args, array(
        'reply-text'=> 'Cevapla',
        'depth' => $depth,
        'max_depth' => $args['max_depth']
    )));
?>

Bu koddaki $args['max_depth'] kısmı, makalenin başında admin panelinden ayarladığımız kademeli yorum seviyesidir. comment_reply_link() fonksiyonunu buradan daha detaylı inceleyebilirsiniz.
Cevapla linkine tıklandığında yorum formu article taglerinin hemen bitişine yerleşecektir. Tasarımınızı yine buna göre ayarlamanız gerekmektedir.

Kaynaklar

• http://www.niharsworld.com/2008/12/16/how-to-implement-threaded-comments-in-wordpress-themes/
• http://codex.wordpress.org/Function
• http://bavotasan.com/2009/how-to-add-nested-comments-to-your-wordpress-theme/

Tasarım Safhası

Blog’u çizerken bir çok tema inceledim, yazılar okudum, fikir aldım… ve sonra fazla renkli olmayan, klasik fakat son modaya da uygun bir tasarım yapmam gerektiğine karar verdim. Uzun düşünmeler ve uğraşlar sonucunda bu tasarımı çizmeyi başardım ve umarım güzel olmuştur. Her zamanki gibi yazı tipleri sorunu beni yine uğraştırdı ve Calibri, Ayita ve Arial yazı tipleri ile işin içinden sorunsuzca çıktım. Renk olarak da beyaz arkaplanda gri ve sarı tonlarındaki renkleri kullandım. Kafamdaki tasarımı direkt tek PSD’de çizerek işi bitirmeye çalıştım. Tasarımı laptopta yapmak zorunda kaldığım için monitör renk seçimim konusunda beni çok yanılttı. Çizdiğim tasarım farklı bilgisayarlarda benim çizdiğimden çok daha farklı tonlarda görüntüleniyordu. Bunu da farklı bilgisayarlarda tonları deneyerek hallettim (en kısa zamanda masaüstü bilgisayara geçiş yapmalıyım…).

Tasarımı xHtml, Css ve JavaScript’e Döküm Safhası

Photoshop kullanarak çizdiğim tasarımı direkt WordPress’e entegre etme hatasına düşmedim bu sefer. Bu sayede hem W3C Validation’a uygun kod yazdım hem de daha derli toplu bi kod ortaya çıktı. Header’a jQuery kullarak hazırladığım bir menu koydum. Ayrıca jQuery’yi Sidebar’daki ‘Sponsor’ bölümündeki büyük afişi ters çevirmek için de kullandım. Footer’da ise Tabmenu’deki geçiş sırasında jQuery’nin fade nimetini kullandım. Standartların dışında yazı tipi kullanabilmek için @font-face yöntemini tercih ettim. Footer’ın bir kısmı haricinde tasarımın tamamında Calibri yazı tipini kullandım. Başlıklarda ise Ayita… Kodlama esnasında IE 7,8,9, FireFox, Chrome, Opera ve Safari tarayıcılarını baz aldım ve onlara göre iyileştirmeler yaptım. Yani kısaca Internet Explorer 6 umrumda bile değil.

Tasarımı WordPress’e Entegre Safhası

Bir kez daha aşık etti beni kendine bu script. WordPress’in fonksiyonları dışında kullanmak zorunda olduğum eklentiler oldu. Bunlar;

• İletişim sayfası için Contact Form 7,
• RSS hizmeti için FeedBurner FeedSmith,
• Yorumlar için IntenseDebate,
• Navigasyon için Yoast Breadcrumbs,

Footerdaki Tabmenu için (Son Yorumlar, Son Yazılar, Popüler Yazılar) ufak üç tane fonksiyon hazırladım. Ve bunlar işimi çok kolaylaştırdı. Tasarımı yaparken öğrendiğim şeylerden birisi de buydu.

Yorumlama Sistemi

Yazılara eklenecek yorumları IntenseDebate uygulaması ile bütünleştirdim. Bu harika uygulama sayesinde hem yorumları kontrol etmek daha kolay oldu hem de bana büyük bir zaman kazancı sağladı.

Sosyal Ağ

Kişisel hesaplarımla blogumu bütünleştirdim ve artık FriendFeed, Twitter, FaceBook ağlarında takipleşebileceğiz. Bunlar dışında Flickr, GooGLe gibi ağlarda da zamanla bulunacağım. Ayrıca Twitter veya FriendFeed ile blog arasına ilgiye göre uygulamalarından yararlanarak bir köprü de kurmayı düşünüyorum daha sonra.