#include <stdio.h>

int main() {
    int sayilar[] = {10, 20, 30, 40, 50};

    printf("\nSayilar[0]: %d", sayilar[0]);
    printf("*(sayilar + 0): %d\n", *(sayilar + 0));

    printf("Sayilar[2]: %d", sayilar[2]);
    printf("*(sayilar + 2): %d\n", *(sayilar + 2));

    // İşaretçi ile dizi elemanlarına erişim
    int *ptr_dizi = sayilar; // ptr_dizi = &sayilar[0]
    printf("\nİşaretçi ile Sayilar[3]: %d\n", *(ptr_dizi + 3)); // 40

    return 0;
}

#include <stdio.h>

void degeriDegistir(int *x) {
    printf("\nFonksiyon içinde adres: %p", x);
    *x = 100; // x'in gösterdiği adresteki değeri 100 yap
}

int main() {
    int sayi = 50;
    printf("\nFonksiyon öncesi sayi: %d", sayi); // 50
    printf("\nmain içinde sayi'nin adresi: %p\n", &sayi);

    degeriDegistir(&sayi); // 'sayi' değişkeninin adresini fonksiyona gönder

    printf("\nFonksiyon sonrası sayi: %d\n", sayi); // 100
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n; // Dizi boyutu

    printf("\nKaç adet tamsayı depolamak istersiniz? ");
    scanf("%d", &n);

    // malloc ile n adet int için bellek ayırma
    arr = (int*) malloc(n * sizeof(int)); // int* türüne cast etmeyi unutmayın

    // Bellek tahsisinin başarılı olup olmadığını kontrol edin
    if (arr == NULL) {
        printf("Bellek tahsisi başarısız!\n");
        return 1; // Hata kodu döndür
    }

    printf("Değerleri giriniz:\n");
    for (int i = 0; i < n; i++) {
        printf("Eleman %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    printf("Girilen değerler:\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // Tahsis edilen belleği serbest bırakma
    free(arr);
    printf("Bellek serbest bırakıldı.\n");

    return 0;
}

#include <iostream>

int main() {
    // Tek bir tamsayı için bellek tahsisi
    int *sayiPtr = new int; 
    *sayiPtr = 42;
    std::cout << "Tek int değeri: " << *sayiPtr << std::endl;
    delete sayiPtr; // Belleği serbest bırak
    sayiPtr = nullptr; // Dangling pointer'ı önlemek için null'a ata

    // 5 adet tamsayıdan oluşan bir dizi için bellek tahsisi
    int *diziPtr = new int[5];
    for (int i = 0; i < 5; ++i) {
        diziPtr[i] = (i + 1) * 10;
    }

    std::cout << "Dizi elemanları: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << diziPtr[i] << " ";
    }
    std::cout << std::endl;

    delete[] diziPtr; // Dizi belleğini serbest bırak
    diziPtr = nullptr; // Dangling pointer'ı önlemek için null'a ata

    return 0;
}

#include <iostream>

int main() {
    int *ptr = nullptr; // İşaretçiyi başlat

    // ptr = new int; // Önce bellek tahsis etmeliyiz

    if (ptr != nullptr) {
        *ptr = 10; // Sadece NULL değilse kullan
        std::cout << *ptr << std::endl;
        delete ptr;
    } else {
        std::cout << "Hata: İşaretçi NULL, belleğe erişilemez." << std::endl;
    }

    return 0;
}

#include <iostream>
#include <memory> // Akıllı işaretçiler için gerekli başlık

int main() {
    // std::unique_ptr kullanımı: Tek sahiplik
    std::cout << "\n--- std::unique_ptr --- " << std::endl;
    std::unique_ptr<int> unique_sayi(new int(100));
    std::cout << "unique_sayi değeri: " << *unique_sayi << std::endl;
    // std::unique_ptr<int> unique_sayi_kopyasi = unique_sayi; // HATA: unique_ptr kopyalanamaz!
    std::unique_ptr<int> unique_sayi_tasi = std::move(unique_sayi); // Sahiplik aktarımı
    std::cout << "unique_sayi_tasi değeri: " << *unique_sayi_tasi << std::endl;
    if (unique_sayi == nullptr) {
        std::cout << "unique_sayi artık nullptr'ı işaret ediyor (taşındı)." << std::endl;
    }
    // unique_sayi_tasi kapsam dışına çıktığında bellek otomatik serbest kalır.

    // std::shared_ptr kullanımı: Paylaşımlı sahiplik
    std::cout << "\n--- std::shared_ptr --- " << std::endl;
    std::shared_ptr<double> shared_deger1(new double(3.14));
    std::cout << "shared_deger1 değeri: " << *shared_deger1 
              << ", referans sayısı: " << shared_deger1.use_count() << std::endl; // 1

    std::shared_ptr<double> shared_deger2 = shared_deger1; // Kopyalama, sahiplik paylaşımı
    std::cout << "shared_deger2 değeri: " << *shared_deger2 
              << ", referans sayısı (shared_deger1): " << shared_deger1.use_count() << std::endl; // 2

    std::shared_ptr<double> shared_deger3(shared_deger1); // Başka bir kopyalama
    std::cout << "shared_deger3 değeri: " << *shared_deger3 
              << ", referans sayısı (shared_deger1): " << shared_deger1.use_count() << std::endl; // 3

    shared_deger1.reset(); // shared_deger1 artık kaynağı göstermiyor
    std::cout << "shared_deger1 resetlendi. Referans sayısı (shared_deger2): " 
              << shared_deger2.use_count() << std::endl; // 2
    // shared_deger2 ve shared_deger3 kapsam dışına çıktığında bellek otomatik serbest kalır.

    // std::weak_ptr kullanımı: shared_ptr ile birlikte
    std::cout << "\n--- std::weak_ptr --- " << std::endl;
    std::shared_ptr<int> sp(new int(200));
    std::weak_ptr<int> wp = sp; // weak_ptr sahiplik sayısını artırmaz

    if (auto locked_sp = wp.lock()) { // weak_ptr'ı shared_ptr'a dönüştürerek kullan
        std::cout << "weak_ptr üzerinden değer: " << *locked_sp << std::endl;
    } else {
        std::cout << "Kaynak yok edildi." << std::endl;
    }

    sp.reset(); // shared_ptr'ı sıfırla, kaynak yok edilir (çünkü başka shared_ptr yok)

    if (auto locked_sp = wp.lock()) {
        std::cout << "weak_ptr üzerinden değer: " << *locked_sp << std::endl;
    } else {
        std::cout << "Kaynak yok edildi." << std::endl; // Şimdi burası çalışır
    }

    return 0;
}