C++ Söz Dizimi Temelleri

Her dilin grameri olduğu gibi, her programlama dilinin de söz dizimi (syntax) kuralları vardır. Türkçe'de cümle sonuna nokta koyarsın, C++'ta noktalı virgül koyarsın. Bu kuralları bilmezsen derleyici seni anlamaz ve hata verir.

Bu derste C++'ın temel söz dizimi kurallarını öğreneceğiz. Bunlar her program yazışında kullanacağın yapı taşları.

Noktalı Virgül: Her İfadenin Sonu

C++'ta her ifade (statement) noktalı virgül (;) ile biter. Bu, derleyiciye "bu ifade burada bitiyor" demektir.

#include <iostream>

int main() {
    int x = 10;                          // ifade 1
    int y = 20;                          // ifade 2
    std::cout << x + y << std::endl;     // ifade 3
    return 0;                            // ifade 4
}

📝 Analoji: Noktalı virgülü Türkçe'deki nokta gibi düşün. Nokta koymazsan cümleler birbirine karışır. C++'ta noktalı virgül koymazsan derleyici ifadeleri ayırt edemez.

Noktalı Virgül Gerekmeyenler

Her satıra noktalı virgül koymuyorsun. Bazı yapılarda gerekmez:

#include <iostream>       // Preprocessor direktifi — ; yok
// Bu bir yorum            // Yorum — ; yok

int main() {              // Fonksiyon başlığı — ; yok
    if (true) {           // if bloğu — ; yok
        // ...
    }                     // Kapanan süslü parantez — ; yok
    return 0;             // İfade — ; VAR
}

Genel kural: Süslü parantezle biten blokların sonuna `;` koymuyorsun (fonksiyon tanımları, if/else, döngüler). Ama sınıf (class) ve struct tanımları istisna — onların sonuna ; koyarsın:

class Araba {
    // ...
};  // Bu noktalı virgül zorunlu!

struct Nokta {
    double x;
    double y;
};  // Bu da zorunlu!

⚠️ Dikkat: Sınıf ve struct tanımından sonra ; koymayı unutmak çok yaygın bir hatadır. Derleyici genellikle anlamsız bir hata mesajı verir ve sorunun kaynağını bulmak zor olabilir.

Süslü Parantezler: Kod Blokları

Süslü parantezler { } bir kod bloğu tanımlar. Fonksiyonlar, koşullar, döngüler — hepsi süslü parantezle çevrelenir.

#include <iostream>

int main() {                         // Blok başlangıcı
    int sayi = 42;

    if (sayi > 0) {                  // İç blok başlangıcı
        std::cout << "Pozitif" << std::endl;
    }                                // İç blok sonu

    for (int i = 0; i < 3; ++i) {   // Döngü bloğu
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}                                    // Blok sonu

Girintileme (Indentation)

C++ girintilemeye (boşluklara) duyarsızdır. Aşağıdaki iki kod aynı işi yapar:

// Okunabilir
int main() {
    int x = 5;
    if (x > 0) {
        std::cout << "Pozitif";
    }
    return 0;
}

// Okunmaz ama derlenir
int main(){int x=5;if(x>0){std::cout<<"Pozitif";}return 0;}

Derleyici ikisini de kabul eder ama ilk versiyonu yaz. Kodu okuyan insanlar (ve gelecekteki sen) sana teşekkür edecek.

Girintileme Stilleri

İki yaygın stil var:

// K&R / 1TBS stili (en yaygın)
if (kosul) {
    // kod
} else {
    // kod
}

// Allman stili
if (kosul)
{
    // kod
}
else
{
    // kod
}

Hangisini seçersen seç, tutarlı ol. Projede bir stil seçilmişse ona uy.

Büyük-Küçük Harf Duyarlılığı

C++ büyük-küçük harf duyarlıdır (case-sensitive). Bu çok önemli:

int sayi = 10;
int Sayi = 20;
int SAYI = 30;
// Bunlar ÜÇ FARKLI değişken!

std::cout << sayi;  // 10
std::cout << Sayi;  // 20
std::cout << SAYI;  // 30

Anahtar kelimeler (keywords) her zaman küçük harfle yazılır:

int x = 5;      // Doğru
Int x = 5;      // YANLIŞ — Int diye bir tip yok
INT x = 5;      // YANLIŞ

return 0;       // Doğru
Return 0;       // YANLIŞ
RETURN 0;       // YANLIŞ

if (true) {}    // Doğru
If (true) {}    // YANLIŞ
IF (true) {}    // YANLIŞ

C++ Anahtar Kelimeleri

C++'ta yaklaşık 90+ anahtar kelime var. İşte en sık kullanılanlar:

Bu anahtar kelimeleri değişken ya da fonksiyon adı olarak kullanamazsın.

Yorum Satırları

Yorumlar, kodun ne yaptığını açıklamak için yazılır. Derleyici yorumları tamamen yok sayar — programın çalışmasını etkilemez.

Tek Satırlık Yorum: //

int yas = 25;  // Kullanicinin yasi
// Bu satirin tamami yorum

// işaretinden satır sonuna kadar her şey yorum sayılır.

Çok Satırlık Yorum: /* */

/* Bu bir
   cok satirli
   yorum blogu */

/* Gecici olarak devre disi birakilan kod:
int x = 10;
int y = 20;
std::cout << x + y;
*/

/* ile başlar, */ ile biter. Arasındaki her şey yorum sayılır.

Yorum Yazma Kuralları

İyi yorum: Kodun *neden* yazıldığını açıklar.

// Kullanici girisini dogrula: bos string kabul etme
if (isim.empty()) {
    std::cout << "Isim bos olamaz!" << std::endl;
}

Kötü yorum: Kodun *ne yaptığını* tekrar eder.

// x'e 1 ekle
x = x + 1;  // Bu zaten açık — yoruma gerek yok

Geçici yorum: Kod geliştirirken test amaçlı kullanılır.

// TODO: Bu fonksiyonu optimize et
// FIXME: Negatif sayilarda hata veriyor
// HACK: Gecici cozum, duzeltilecek

💡 İpucu: Kodun kendisi "ne yaptığını" söylemeli, yorumlar "neden yaptığını" söylemeli. Anlaşılır değişken ve fonksiyon isimleri kullanırsan çoğu yorum gereksiz olur.

Değişken Tanımlama ve İsimlendirme

Temel Değişken Tanımlama

tip degisken_adi = deger;

int yas = 25;
double maas = 15000.50;
char harf = 'A';
bool aktif = true;
std::string isim = "Ali";  // string icin #include <string> gerekebilir

Değişken İsimlendirme Kuralları

C++'ta değişken isimleri için kesin kurallar var:

// Gecerli isimler
int sayi = 10;
int _gecici = 20;
int sayi2 = 30;
int toplamDeger = 100;
int MAKSIMUM_BOYUT = 1000;

// Gecersiz isimler
int 2sayi = 10;        // Rakamla baslayamaz
int toplam deger = 20;  // Bosluk icermez
int class = 5;          // Anahtar kelime
int toplam-deger = 30;  // Tire kullanilmaz

İsimlendirme Convention'ları

C++ topluluğunda yaygın isimlendirme stilleri:

// camelCase — Değişkenler ve fonksiyonlar için (en yaygın)
int toplamFiyat = 100;
void hesaplaOrtalama();

// snake_case — Değişkenler ve fonksiyonlar için (STL tarzı)
int toplam_fiyat = 100;
void hesapla_ortalama();

// PascalCase — Sınıflar ve tipler için
class OgrenciBilgisi {};
struct VeriPaketi {};

// UPPER_SNAKE_CASE — Sabitler ve makrolar için
const int MAKSIMUM_BOYUT = 100;
#define PI 3.14159

Hangi stili seçersen seç, tutarlı ol. Bir projede birden fazla stil karıştırmak kodu okunmaz yapar.

⚠️ Dikkat: Çift alt çizgi (__) ile başlayan veya tek alt çizgi + büyük harf (_A) ile başlayan isimler derleyiciye ayrılmıştır. Bunları kullanma: __deger, _Toplam gibi isimlerden kaçın.

auto ile Tip Çıkarımı

C++11'den itibaren derleyici değişkenin tipini kendisi çıkarabilir:

auto sayi = 42;          // int
auto pi = 3.14;          // double
auto isim = "Ali";       // const char*
auto harf = 'A';         // char
auto aktif = true;       // bool

// Daha karmasik tiplerde cok kullanisli
auto sonuc = std::vector<int>{1, 2, 3, 4, 5};

auto uzun tip isimlerinde çok kullanışlıdır. Ama basit durumlarda tipi açıkça yazmak okunabilirliği artırabilir.

const — Değişmeyen Değerler

Bir değişkenin değerini değiştirmek istemiyorsan const kullan:

const double PI = 3.14159265;
const int MAKS_OGRENCI = 50;
const std::string OKUL_ADI = "Bilgi Universitesi";

PI = 3.14;  // HATA! const değişken değiştirilemez

const kullanmak:

• Kodun okunabilirliğini artırır (bu değer değişmeyecek diye anlaşılır).

• Yanlışlıkla değer değiştirmeyi engeller.

• Derleyiciye optimizasyon fırsatı verir.

constexpr — Derleme Zamanı Sabitleri

C++11 ile gelen constexpr, değerin derleme zamanında hesaplanmasını garanti eder:

constexpr double PI = 3.14159265;
constexpr int KARE = 5 * 5;           // Derleme zamanında 25 olur
constexpr int FAKTORIYEL = 1*2*3*4*5; // Derleme zamanında 120 olur

const ve constexpr farkı: const çalışma zamanında da atanabilir, constexpr kesinlikle derleme zamanında bilinmelidir.

int kullanici_girisi;
std::cin >> kullanici_girisi;

const int x = kullanici_girisi;       // OK — const çalışma zamanında atanabilir
constexpr int y = kullanici_girisi;   // HATA — derleme zamanında bilinmiyor!

Preprocessor Directive'leri

# ile başlayan satırlar preprocessor directive (ön işlemci direktifi) dir. Bunlar derleme başlamadan önce işlenir.

#include — Dosya Dahil Etme

Bunu zaten biliyorsun:

#include <iostream>      // Standart kütüphane header'ı
#include "my_header.h"   // Kendi header dosyan

#define — Makro Tanımlama

#define PI 3.14159
#define MAKS 100
#define KARE(x) ((x) * (x))

double alan = PI * r * r;     // PI → 3.14159 olarak değiştirilir
int sonuc = KARE(5);          // ((5) * (5)) → 25

Preprocessor #define ile tanımlanan isimleri metin olarak değiştirir. Bu basit bir bul-değiştir işlemidir.

Modern C++'ta `#define` yerine `const` veya `constexpr` tercih et:

// Eski yol (makro) — kaçın
#define PI 3.14159
#define MAKS 100

// Modern yol — tercih et
constexpr double PI = 3.14159;
constexpr int MAKS = 100;

Neden? Makrolar tip güvenliği sağlamaz ve hata ayıklamayı zorlaştırır. constexpr sabitleri ise gerçek değişkenlerdir — tip kontrolü yapılır, hata mesajları anlamlıdır.

#ifdef / #ifndef — Koşullu Derleme

Kodun belirli kısımlarını koşula göre derlemeye dahil etmek veya çıkarmak için:

#include <iostream>

#define DEBUG

int main() {
    int sonuc = 42;

    #ifdef DEBUG
        std::cout << "[DEBUG] sonuc = " << sonuc << std::endl;
    #endif

    std::cout << "Program calisiyor..." << std::endl;
    return 0;
}

DEBUG tanımlıysa debug mesajı yazdırılır, tanımlı değilse o satırlar derlemeye dahil edilmez. Bu teknik büyük projelerde sıkça kullanılır.

#if / #elif / #else — Daha Karmaşık Koşullar

#define PLATFORM 1  // 1: Windows, 2: Linux, 3: Mac

#if PLATFORM == 1
    #include <windows.h>
    // Windows'a özel kod
#elif PLATFORM == 2
    #include <unistd.h>
    // Linux'a özel kod
#else
    // Diğer platformlar
#endif

Bu yapı, aynı kaynak kodun farklı platformlarda farklı davranmasını sağlar.

#pragma — Derleyiciye Özel Talimatlar

#pragma once       // Header'ın birden fazla dahil edilmesini engeller
#pragma warning(disable: 4996)  // MSVC'de belirli uyarıyı kapat

#pragma standart dışıdır ama pratikte tüm büyük derleyiciler destekler.

Boşluklar ve Biçimlendirme

C++ boşluklara (whitespace) büyük ölçüde duyarsızdır. Boşluk, tab ve satır sonu derleyici için aynıdır:

// Hepsi aynı anlama gelir:
int x=5;
int x = 5;
int   x   =   5;
int
x
=
5
;

Ama okunabilirlik için standart biçimlendirme kuralları var:

// İyi biçimlendirme
#include <iostream>

int main() {
    int a = 10;
    int b = 20;

    if (a > b) {
        std::cout << "a buyuk" << std::endl;
    } else {
        std::cout << "b buyuk veya esit" << std::endl;
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

Biçimlendirme Araçları

Kodu elle biçimlendirmekle uğraşma — araçlar var:

• clang-format — En yaygın C++ biçimlendirici. .clang-format dosyasıyla stilleri özelleştirebilirsin.

• VS Code: "Format Document" (Shift+Alt+F) kısayoluyla otomatik biçimlendirme.

# clang-format ile biçimlendirme
clang-format -i main.cpp    # Dosyayı yerinde biçimlendir

İfadeler ve İfade Türleri

C++'ta farklı ifade türleri vardır:

Bildirim İfadesi (Declaration Statement)

int x;                    // Değişken bildirimi
int y = 10;               // Bildirim + ilk değer atama
double pi = 3.14;
std::string mesaj = "Merhaba";

Atama İfadesi (Assignment Statement)

x = 5;          // Değer atama
x = x + 1;      // Mevcut değeri güncelleme
x += 3;         // Kısa yol: x = x + 3
x++;            // Kısa yol: x = x + 1

Çıktı İfadesi (Output Statement)

std::cout << "Merhaba" << std::endl;
std::cout << x << " + " << y << " = " << x + y << std::endl;

Bileşik İfade (Compound Statement / Block)

{
    int temp = a;
    a = b;
    b = temp;
}
// temp burada erişilemez — blok içinde tanımlandı

Süslü parantezlerle çevrili bir grup ifade. İçinde tanımlanan değişkenler sadece o blok içinde yaşar (scope).

Kapsam (Scope)

Bir değişkenin erişilebilir olduğu bölgeye kapsam (scope) denir:

#include <iostream>

int global = 100;  // Global kapsam — her yerden erişilir

int main() {
    int lokal = 50;  // main kapsamı

    if (true) {
        int ic = 25;  // if bloğu kapsamı
        std::cout << global << std::endl;  // OK
        std::cout << lokal << std::endl;   // OK
        std::cout << ic << std::endl;      // OK
    }

    std::cout << global << std::endl;  // OK
    std::cout << lokal << std::endl;   // OK
    // std::cout << ic << std::endl;   // HATA! ic bu kapsamda yok

    return 0;
}

Kural basit: bir değişken, tanımlandığı { } bloğu içinde yaşar. Blok bitince değişken yok olur.

💡 İpucu: Değişkenleri mümkün olduğunca dar kapsamda tanımla. Global değişkenlerden kaçın — kodun test edilmesini ve anlaşılmasını zorlaştırırlar.

Tam Bir Örnek

Öğrendiğimiz tüm kavramları bir arada kullanalım:

// Dosya: hesap_makinesi.cpp
// Basit bir hesap makinesi programi

#include <iostream>
#include <string>

// Sabitler
constexpr double PI = 3.14159265;
constexpr int VERSIYON = 1;

// Fonksiyon bildirimi
double daireAlani(double yaricap);

int main() {
    // Degisken tanimlama
    std::string program_adi = "Mini Hesap Makinesi";
    double yaricap = 0.0;

    // Cikti
    std::cout << program_adi << " v" << VERSIYON << std::endl;
    std::cout << "Yaricap girin: ";

    // Girdi
    std::cin >> yaricap;

    // Hesaplama ve sonuc
    double alan = daireAlani(yaricap);
    std::cout << "Daire alani: " << alan << std::endl;

    return 0;
}

// Fonksiyon tanimi
double daireAlani(double yaricap) {
    return PI * yaricap * yaricap;
}

Bu programda gördüğümüz kavramlar:

• #include direktifleri

• constexpr sabitler

• Fonksiyon bildirimi ve tanımı

• Değişken tanımlama ve isimlendirme

• cout ve cin kullanımı

• Yorum satırları

• Süslü parantezler ve kapsam

• Noktalı virgüller

Özet

• Her C++ ifadesi noktalı virgül (;) ile biter; süslü parantezle biten bloklar istisnadır (sınıf/struct hariç).

• Süslü parantezler { } kod bloklarını tanımlar; girintileme zorunlu değildir ama okunabilirlik için şarttır.

• C++ büyük-küçük harf duyarlıdır: sayi, Sayi ve SAYI üç farklı değişkendir; anahtar kelimeler her zaman küçük harfle yazılır.

• Yorumlar (// ve /* */) kodun neden yazıldığını açıklar; derleyici tarafından yok sayılır.

• Değişken isimleri harf veya _ ile başlamalı; camelCase veya snake_case convention'larından birini tutarlı kullan.

• Preprocessor directive'leri (#define, #ifdef) derleme öncesi metin işleme yapar; modern C++'ta sabitler için constexpr tercih edilmelidir.