C++ Notları ve İpuçları

İçindekiler

1. Temel Sözdizimi
2. Veri Tipleri
3. Değişkenler
4. Operatörler
5. Kontrol Akışı
6. Fonksiyonlar
7. Diziler ve İşaretçiler
8. Nesne Yönelimli Programlama
9. Şablonlar
10. Standart Şablon Kütüphanesi (STL)
11. İstisna Yönetimi
12. Dosya İşlemleri
13. Bellek Yönetimi
14. Önişlemci Yönergeleri

Temel Sözdizimi

Yorumlar

// Bu bir tek satırlık yorumdur

/*
Bu bir
çok satırlı yorumdur
*/

Ana Fonksiyon

Her C++ programı ana fonksiyondan başlar:

#include <iostream>

int main() {
    std::cout << "Merhaba, Dünya!" << std::endl;
    return 0;
}

Veri Tipleri

İlkel Veri Tipleri

bool b = true;
char c = 'A';
short s = 32767;
int i = 2147483647;
long l = 9223372036854775807L;
float f = 3.14f;
double d = 3.14159265359;

Türetilmiş Veri Tipleri

int arr[5];  // Dizi
int* ptr;    // İşaretçi
int& ref = i;  // Referans

Değişkenler

// Değişken bildirimi
int sayi;

// Değişken başlatma
sayi = 10;

// Bildirme ve başlatma
int yas = 25;

// Sabitler
const double PI = 3.14159;

// Auto anahtar kelimesi
auto x = 5;  // x'in int olduğu çıkarılır

Operatörler

Aritmetik Operatörler

int a = 10, b = 3;

std::cout << a + b << std::endl;  // Toplama: 13
std::cout << a - b << std::endl;  // Çıkarma: 7
std::cout << a * b << std::endl;  // Çarpma: 30
std::cout << a / b << std::endl;  // Bölme: 3
std::cout << a % b << std::endl;  // Mod alma: 1

Karşılaştırma Operatörleri

int x = 5, y = 10;

std::cout << (x == y) << std::endl;  // Eşittir: 0 (yanlış)
std::cout << (x != y) << std::endl;  // Eşit değildir: 1 (doğru)
std::cout << (x > y) << std::endl;   // Büyüktür: 0 (yanlış)
std::cout << (x < y) << std::endl;   // Küçüktür: 1 (doğru)
std::cout << (x >= y) << std::endl;  // Büyük eşittir: 0 (yanlış)
std::cout << (x <= y) << std::endl;  // Küçük eşittir: 1 (doğru)

Mantıksal Operatörler

bool a = true, b = false;

std::cout << (a && b) << std::endl;  // Mantıksal VE: 0 (yanlış)
std::cout << (a || b) << std::endl;  // Mantıksal VEYA: 1 (doğru)
std::cout << (!a) << std::endl;      // Mantıksal DEĞİL: 0 (yanlış)

Kontrol Akışı

If-Else İfadesi

int x = 10;

if (x > 0) {
    std::cout << "Pozitif" << std::endl;
} else if (x < 0) {
    std::cout << "Negatif" << std::endl;
} else {
    std::cout << "Sıfır" << std::endl;
}

Switch İfadesi

int gun = 3;
switch (gun) {
    case 1:
        std::cout << "Pazartesi" << std::endl;
        break;
    case 2:
        std::cout << "Salı" << std::endl;
        break;
    case 3:
        std::cout << "Çarşamba" << std::endl;
        break;
    default:
        std::cout << "Diğer gün" << std::endl;
}

For Döngüsü

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

// Aralık tabanlı for döngüsü (C++11)
int sayilar[] = {1, 2, 3, 4, 5};
for (int sayi : sayilar) {
    std::cout << sayi << " ";
}
std::cout << std::endl;

While Döngüsü

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

Do-While Döngüsü

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

Fonksiyonlar

// Fonksiyon bildirimi
int topla(int a, int b);

// Fonksiyon tanımı
int topla(int a, int b) {
    return a + b;
}

// Fonksiyon aşırı yükleme
double topla(double a, double b) {
    return a + b;
}

// Varsayılan argümanlar
void selamla(std::string isim = "Dünya") {
    std::cout << "Merhaba, " << isim << "!" << std::endl;
}

// Satır içi fonksiyon
inline int kare(int x) {
    return x * x;
}

// Lambda fonksiyonu (C++11)
auto carp = [](int a, int b) { return a * b; };

Diziler ve İşaretçiler

// Dizi bildirimi ve başlatma
int sayilar[5] = {1, 2, 3, 4, 5};

// Dizi elemanlarına erişim
std::cout << sayilar[0] << std::endl;  // 1 yazdırır

// İşaretçi bildirimi ve başlatma
int* ptr = sayilar;

// İşaretçi aritmetiği
std::cout << *ptr << std::endl;       // 1 yazdırır
std::cout << *(ptr + 1) << std::endl; // 2 yazdırır

// Dinamik bellek tahsisi
int* dinamikDizi = new int[5];
delete[] dinamikDizi;

Nesne Yönelimli Programlama

Sınıf Tanımı

class Araba {
private:
    std::string marka;
    std::string model;

public:
    // Yapıcı
    Araba(std::string marka, std::string model) : marka(marka), model(model) {}

    // Yıkıcı
    ~Araba() {}

    // Üye fonksiyon
    void baslat() {
        std::cout << "Araba çalışıyor..." << std::endl;
    }

    // Getter
    std::string getMarkaAl() const {
        return marka;
    }

    // Setter
    void markaAyarla(const std::string& yeniMarka) {
        marka = yeniMarka;
    }
};

Nesne Oluşturma ve Kullanımı

Araba arabam("Toyota", "Corolla");
arabam.baslat();
std::cout << arabam.getMarkaAl() << std::endl;

Kalıtım

class ElektrikliAraba : public Araba {
private:
    int bataryaKapasitesi;

public:
    ElektrikliAraba(std::string marka, std::string model, int bataryaKapasitesi)
        : Araba(marka, model), bataryaKapasitesi(bataryaKapasitesi) {}

    void baslat() override {
        std::cout << "Elektrikli araba sessizce çalışıyor..." << std::endl;
    }
};

Şablonlar

// Fonksiyon şablonu
template <typename T>
T maksimum(T a, T b) {
    return (a > b) ? a : b;
}

// Sınıf şablonu
template <typename T>
class Kutu {
private:
    T icerik;

public:
    void icerigiAyarla(T icerik) {
        this->icerik = icerik;
    }

    T icerigiAl() {
        return icerik;
    }
};

Standart Şablon Kütüphanesi (STL)

Vektörler

#include <vector>

std::vector<int> sayilar = {1, 2, 3, 4, 5};
sayilar.push_back(6);
std::cout << sayilar[0] << std::endl;  // 1 yazdırır
std::cout << sayilar.size() << std::endl;  // 6 yazdırır

Haritalar

#include <map>

std::map<std::string, int> yaslar;
yaslar["Ali"] = 30;
yaslar["Ayşe"] = 25;
std::cout << yaslar["Ali"] << std::endl;  // 30 yazdırır

Algoritmalar

#include <algorithm>

std::vector<int> sayilar = {3, 1, 4, 1, 5, 9, 2, 6, 5};
std::sort(sayilar.begin(), sayilar.end());
auto it = std::find(sayilar.begin(), sayilar.end(), 5);

İstisna Yönetimi

#include <stdexcept>

try {
    int sonuc = 10 / 0;
} catch (const std::exception& e) {
    std::cerr << "İstisna yakalandı: " << e.what() << std::endl;
} catch (...) {
    std::cerr << "Bilinmeyen istisna yakalandı" << std::endl;
}

// İstisna fırlatma
void yasiKontrolEt(int yas) {
    if (yas < 0) {
        throw std::invalid_argument("Yaş negatif olamaz");
    }
}

Dosya İşlemleri

#include <fstream>

// Dosyaya yazma
std::ofstream cikisDosyasi("cikis.txt");
cikisDosyasi << "Merhaba, Dünya!" << std::endl;
cikisDosyasi.close();

// Dosyadan okuma
std::ifstream girisDosyasi("giris.txt");
std::string satir;
while (std::getline(girisDosyasi, satir)) {
    std::cout << satir << std::endl;
}
girisDosyasi.close();

Bellek Yönetimi

// Dinamik bellek tahsisi
int* ptr = new int;
*ptr = 10;
delete ptr;

// Dinamik dizi tahsisi
int* dizi = new int[5];
delete[] dizi;

// Akıllı işaretçiler (C++11)
#include <memory>

std::unique_ptr<int> tekPtr = std::make_unique<int>(42);
std::shared_ptr<int> paylasimliPtr = std::make_shared<int>(42);

Önişlemci Yönergeleri

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

#ifdef DEBUG
    std::cout << "Hata ayıklama modu açık" << std::endl;
#endif

#ifndef BASLIGIM_H
#define BASLIGIM_H
// Başlık dosyası içeriği
#endif