Docs

tnrdll

C++ nesneler (objects)

C++ programlama dilinde “nesne” terimi, nesne yönelimli programlamanın (OOP) temel kavramlarından biridir. Nesne yönelimli programlama, gerçek dünyadaki nesneleri modellemek ve bu nesneler arasındaki ilişkileri tanımlamak için bir programlama paradigmasıdır. C++’da nesneler, sınıflar tarafından tanımlanan örneklerdir. İşte C++’da nesneleri tanımlamak için kullanılan temel kavramlar:

Sınıf (Class): Nesnelerin taslağını oluşturan bir şablondur. Sınıflar, veri üyeleri (özellikler) ve bu üyeler üzerinde çalışan fonksiyonları (metodlar) içerebilir.

class Araba {
public:
    // Veri üyeleri
    std::string marka;
    int modelYili;
    
    // Metodlar
    void Calistir() {
        std::cout << "Araba calisti!" << std::endl;
    }
};

Nesne Oluşturma (Object Creation): Sınıftan bir nesne oluşturmak için new anahtar kelimesi kullanılmaz; bunun yerine sınıf adı ve nesne adı kullanılır.

Araba araba1;  // Araba sınıfından bir nesne oluşturuldu

Üye Erişimi (Member Access): Sınıfın veri üyelerine ve metodlarına erişmek için . (nokta) operatörü kullanılır.

araba1.marka = "Nissan";
araba1.modelYili = 2016;
araba1.Calistir();

Kurucu Metot (Constructor): Sınıfın bir nesnesi oluşturulduğunda otomatik olarak çağrılan özel bir metottur. Genellikle sınıfın başlatılmasını sağlamak için kullanılır.

class Araba {
public:
    Araba() {
        std::cout << "Araba objesi oluşturuldu." << std::endl;
    }
};

Nesne oluşturulduğunda kurucu metod otomatik olarak çağrılır:

Araba araba1;  // Araba objesi oluşturuldu.

Bu örnekler, C++ nesne yönelimli programlama kavramlarının temelini oluşturur. Nesne yönelimli programlama, kodun daha düzenli, okunabilir ve sürdürülebilir olmasına yardımcı olabilir.

tnrdll

C++ sınıflar (classes)

C++ dilinde sınıflar, nesne yönelimli programlamayı (OOP) destekleyen temel bir yapıdır. Sınıflar, veri üyeleri (attributes) ve bu veri üzerinde işlemler gerçekleştiren fonksiyonları (metodlar) bir araya getirerek bir veri tipi tanımlamanızı sağlar.

Basit bir C++ sınıfı örneği:

#include <iostream>
#include <string>

// Bir sınıf tanımlama
class Ogrenci {
public: // Erişim belirleyiciler: public, private, protected
    // Veri üyeleri
    std::string ad;
    std::string soyad;
    int yas;

    // Constructor (Yapıcı metod)
    Ogrenci(std::string a, std::string s, int y) : ad(a), soyad(s), yas(y) {
        // Constructor, sınıf bir nesne oluşturulduğunda otomatik olarak çağrılır
        std::cout << "Ogrenci objesi olusturuldu." << std::endl;
    }

    // Member function (Üye fonksiyon)
    void bilgileriGoster() {
        std::cout << "Ad: " << ad << ", Soyad: " << soyad << ", Yas: " << yas << std::endl;
    }
};

int main() {
    // Sınıf nesnesi oluşturma
    Ogrenci ogrenci1("Ahmet", "Yilmaz", 20);

    // Sınıf üye fonksiyonunu çağırma
    ogrenci1.bilgileriGoster();

    return 0;
}

Bu örnekte Ogrenci adlı bir sınıf tanımlanmıştır. Sınıfın veri üyeleri (ad, soyad, yas) public olarak belirlenmiştir, bu nedenle bu üyelere sınıf dışından erişilebilir. Ayrıca, bir constructor (yapıcı metod) tanımlanmıştır, bu metod sınıf bir nesne oluşturulduğunda otomatik olarak çağrılır.

Programın main fonksiyonunda, Ogrenci sınıfından bir nesne oluşturulur ve sınıfın üye fonksiyonu çağrılarak bilgileri ekrana yazdırılır.

Bu sadece temel bir örnektir ve C++ sınıflarının daha karmaşık konseptlerini öğrenmek için daha fazla inceleme yapmanız gerekebilir. Örneğin, özel erişim belirleyicileri (private, protected), destructor (yıkıcı metod), statik üyeler, friend fonksiyonlar ve daha pek çok konu C++ sınıflarıyla ilgili derinleşebileceğiniz konulardan bazılarıdır.

Dairenin alanını ve çevresini hesaplayan C++ sınıfı

Aşağıda, C++ dilinde bir dairenin alanını ve çevresini hesaplayan bir sınıf örneği bulunmaktadır. Bu örnekte, sınıfın veri üyeleri olarak dairenin yarı çapı (yaricap) kullanılmıştır. Sınıfın üye fonksiyonları (AlanHesapla ve CevreHesapla), dairenin alanını ve çevresini hesaplamak için kullanılmaktadır.

#include <iostream>

class Daire {
private:
    double yaricap;

public:
    // Constructor
    Daire(double r) : yaricap(r) {}

    // Alanı hesaplayan üye fonksiyon
    double AlanHesapla() {
        return 3.14 * yaricap * yaricap;
    }

    // Çevreyi hesaplayan üye fonksiyon
    double CevreHesapla() {
        return 2 * 3.14 * yaricap;
    }
};

int main() {
    // Daire sınıfından bir nesne oluşturma
    Daire daire1(5.0);

    // Alanı ve çevreyi hesaplayarak ekrana yazdırma
    std::cout << "Dairenin Alani: " << daire1.AlanHesapla() << std::endl;
    std::cout << "Dairenin Cevresi: " << daire1.CevreHesapla() << std::endl;

    return 0;
}

Bu örnekte, Daire adlı sınıf, yaricap adlı bir özel (private) veri üyesine sahiptir. Constructor, yaricap‘ı başlatmak için kullanılır. Sınıfın üye fonksiyonları olan AlanHesapla ve CevreHesapla, dairenin alanını ve çevresini hesaplamak için yaricap‘ı kullanır.

Programın main fonksiyonunda, Daire sınıfından bir nesne oluşturulur ve bu nesnenin AlanHesapla ve CevreHesapla fonksiyonları çağrılarak sonuçlar ekrana yazdırılır.

tnrdll

C++ enum – enumeration (numaralandırma)

C++ programlamada enum (sıralı tipler) kullanımı, belirli değerlere anlamlar atamak ve bu değerlerle çalışmayı kolaylaştırmak için kullanılır.

#include <iostream>

// Renkleri temsil eden bir enum tanımlama
enum Renk {
    Kirmizi,
    Yesil,
    Mavi,
    Sarı,
    Beyaz
};

int main() {
    // Enum değerlerini kullanma
    Renk secilenRenk = Kirmizi;

    // Enum değerini ekrana yazdırma
    std::cout << "Secilen renk: " << secilenRenk << std::endl;

    // Enum değerini değiştirme
    secilenRenk = Mavi;

    // Değiştirilen enum değerini ekrana yazdırma
    std::cout << "Yeni secilen renk: " << secilenRenk << std::endl;

    return 0;
}

Bu örnekte, Renk adında bir enum tanımlandı ve bu enum içindeki değerler Kirmizi, Yesil, Mavi, Sarı, ve Beyaz olarak belirlendi. Daha sonra, bu enum kullanılarak bir değişken oluşturuldu, bu değişkene başlangıçta Kirmizi değeri atanmış, ardından değeri Mavi olarak değiştirilmiş ve ekrana yazdırılmıştır.

enum kullanmak, programınızda belirli sabit değerlere anlam atamak ve daha okunabilir, anlaşılır kodlar yazmak için oldukça yararlıdır.

tnrdll

C++ struct ile pointer kullanımı

C++ programlamada, struct ve pointer’ları bir araya getirerek dinamik bellek yönetimi, veri yapıları oluşturma ve işlemleri gerçekleştirme imkanınız bulunmaktadır.

#include <iostream>

// Bir öğrenci bilgisini temsil eden struct
struct Ogrenci {
    int numara;
    std::string ad;
    std::string soyad;
};

int main() {
    // Bir Ogrenci struct'ı oluşturun
    Ogrenci ogrenci1;
    ogrenci1.numara = 123;
    ogrenci1.ad = "Ahmet";
    ogrenci1.soyad = "Yilmaz";

    // Ogrenci struct'ının pointer'ını oluşturun ve dinamik bellekten yer ayırın
    Ogrenci* ogrenciPtr = new Ogrenci;

    // Pointer üzerinden struct elemanlarına erişim ve değer atama
    ogrenciPtr->numara = 456;
    ogrenciPtr->ad = "Mehmet";
    ogrenciPtr->soyad = "Demir";

    // Pointer üzerinden struct elemanlarını ekrana yazdırma
    std::cout << "Ogrenci Bilgileri:" << std::endl;
    std::cout << "Numara: " << ogrenciPtr->numara << std::endl;
    std::cout << "Ad: " << ogrenciPtr->ad << std::endl;
    std::cout << "Soyad: " << ogrenciPtr->soyad << std::endl;

    // Dinamik bellekten ayrılan alanı serbest bırak
    delete ogrenciPtr;

    return 0;
}

Bu örnekte, Ogrenci adlı bir struct tanımlanmıştır. Daha sonra, bu struct türünden bir nesne (ogrenci1) oluşturulmuş ve bir diğeri ise dinamik bellekten (new operatörü ile) oluşturulmuştur (ogrenciPtr). Pointer ile struct elemanlarına erişim ve değer atama işlemleri -> operatörü ile yapılmıştır. Son olarak, dinamik bellekten ayrılan alan serbest bırakılmıştır (delete ogrenciPtr). Dinamik bellek yönetimine dikkat etmek önemlidir, aksi halde bellek sızıntılarına neden olabilir.

tnrdll

C++ fonksiyon içerisinde struct kullanımı

C++ dilinde bir fonksiyon içerisinde struct kullanımı oldukça yaygındır. struct, C++ dilinde bir veri yapısı tanımlamak için kullanılan bir anahtar kelimedir.

#include <iostream>
#include <string>

// Bir struct tanımlayalım
struct Ogrenci {
    std::string ad;
    std::string soyad;
    int yas;
};

// Struct'u kullanan bir fonksiyon tanımlayalım
void OgrenciBilgileriniYazdir(const Ogrenci& ogrenci) {
    std::cout << "Ad: " << ogrenci.ad << std::endl;
    std::cout << "Soyad: " << ogrenci.soyad << std::endl;
    std::cout << "Yaş: " << ogrenci.yas << std::endl;
}

int main() {
    // Struct'u kullanalım
    Ogrenci ogrenci1;
    ogrenci1.ad = "Ahmet";
    ogrenci1.soyad = "Yılmaz";
    ogrenci1.yas = 20;

    // Fonksiyonu çağırarak struct içeriğini yazdıralım
    OgrenciBilgileriniYazdir(ogrenci1);

    return 0;
}

Bu örnekte, Ogrenci adlı bir struct tanımlanmıştır. Bu struct, bir öğrencinin adını, soyadını ve yaşını içerir. OgrenciBilgileriniYazdir adlı bir fonksiyon, bir Ogrenci struct’ı alır ve bu bilgileri ekrana yazdırır. main fonksiyonunda bir Ogrenci örneği oluşturulur ve bu örnek, OgrenciBilgileriniYazdir fonksiyonuyla kullanılır.

tnrdll

C++ struct

C++ programlamada, “struct” (structure) veri türü, bir veya birden fazla farklı veri türünden oluşan bir veri grubunu tanımlamak için kullanılır. Bu, farklı veri türlerini tek bir yapı içinde birleştirerek, ilgili verileri organize etmenin ve gruplandırmanın bir yolunu sağlar.

Bir struct tanımlanırken, struct anahtar kelimesi kullanılır. Örnek bir struct tanımı şu şekildedir:

#include <iostream>
using namespace std;

// Bir struct tanımı
struct Ogrenci {
    string ad;
    int yas;
    float notOrtalamasi;
};

int main() {
    // Ogrenci struct'ından bir nesne oluşturma
    Ogrenci ogrenci1;

    // Nesnenin alanlarına değer atama
    ogrenci1.ad = "Ahmet";
    ogrenci1.yas = 20;
    ogrenci1.notOrtalamasi = 85.5;

    // Verilere erişme
    cout << "Ad: " << ogrenci1.ad << endl;
    cout << "Yaş: " << ogrenci1.yas << endl;
    cout << "Not Ortalaması: " << ogrenci1.notOrtalamasi << endl;

    return 0;
}

Bu örnekte, “Ogrenci” isimli bir struct tanımlanmıştır ve bu struct içinde üç farklı türde veri bulunmaktadır: bir string (ad), bir int (yas) ve bir float (notOrtalamasi). Daha sonra, bu struct’tan bir nesne oluşturularak, bu nesnenin alanlarına değer atandı ve bu değerlere erişilerek ekrana yazdırıldı. Struct’lar genellikle ilgili verileri bir araya getirmek ve düzenlemek için kullanılır.

C++ programlamada, struct ve sınıf (class) temel olarak aynı işlevselliğe sahiptir, ancak bazı farklar vardır.

Struct: Varsayılan olarak, struct üyeleri genellikle public (kamusal) olarak kabul edilir. Yani, bir struct içindeki veri elemanlarına başka bir kod bloğundan doğrudan erişilebilir.

Sınıf (Class): Varsayılan olarak, sınıf üyeleri private (özel) olarak kabul edilir. Yani, bir sınıf içindeki veri elemanlarına doğrudan erişim genellikle mümkün değildir.

Struct: Struct’larla kalıtım kullanılabilir, ancak kalıtımın varsayılan erişim düzeyi public‘dir.

struct Base {
    int x;
};

struct Derived : Base {
    int y;
};

Sınıf (Class): Kalıtımın varsayılan erişim düzeyi private‘dir. Yani, kalıtım yapıldığında, temel sınıfın üyeleri genellikle varsayılan olarak private olarak kalır.

class Base {
public:
    int x;
};

class Derived : Base {
    int y;
};
tnrdll

Docker – PHP uygulama ortamı için Docker Compose

Docker Compose, Docker konteyner uygulamalarınızı yönetmek ve birden çok konteyneri bir araya getirmek için kullanılan bir araçtır. Docker Compose, bir YAML dosyasında tanımlanan birden çok servisi ve bu servislerin konfigürasyonlarını içerir. Bu dosya, bir uygulamanın gereksinim duyduğu tüm konteynerleri ve bu konteynerlerin nasıl bir arada çalışacaklarına dair bilgileri içerir.

Dockerfile ise, Docker konteynerlerini oluşturmak için kullanılan bir dosya formatıdır. Dockerfile, bir imaj oluşturmak için adım adım talimatlar içerir. İmaj, bir konteynerin çalıştığı ortamı ve uygulama kodunu içeren bir pakettir.

Docker Compose kullanarak PHP, Apache, MySQL ve phpMyAdmin içeren bir uygulama ortamı oluşturmak için aşağıda örnek bir docker-compose.yml dosyasını bulabilirsin. Bu dosya, bir PHP uygulamasını barındıran Apache sunucusunu, bir MySQL veritabanını ve phpMyAdmin arayüzünü içerir.

version: '3.8'

services:
  # Apache ve PHP servisi
  web:
    image: php:8-apache
    container_name: php-apache-container
    ports:
      - "8080:80"
    volumes:
      - .:/var/www/html

  # MySQL servisi
  mysql:
    image: mysql:8.0
    networks:
      - my-network
    container_name: mysql-container
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: your_database
      MYSQL_USER: your_user
      MYSQL_PASSWORD: your_password
    volumes:
      - ./mysql-data:/var/lib/mysql

  # phpMyAdmin servisi
  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    networks:
      - my-network
    container_name: phpmyadmin-container
    ports:
      - "8081:80"
    environment:
      PMA_HOST: mysql
      MYSQL_ROOT_PASSWORD: root_password
    depends_on:
      - mysql

# Define networks
networks:
  my-network:

Bu dosya, üç servisi (web, mysql, ve phpmyadmin) tanımlar. Servisler arasında bağlantılar için depends_on kullanılarak, MySQL servisinin başlamasının ardından phpMyAdmin servisinin başlamasını sağlar.

Ayrıca, volumes kullanılarak host makinanın dosya sistemine bağlı iki adet volume eklenmiştir. Bu volume’ler, Apache’nin PHP kodunu barındıracağı klasörü (./) ve MySQL’in veritabanı dosyalarını saklayacağı klasörü (./mysql-data) temsil eder. Bu şekilde, container’lar durduğunda bile verileriniz kaybolmaz.

Docker Compose’un networks bölümü, uygulamanın içindeki konteynerler arasında iletişim kurmalarını sağlayan ağları tanımlar. Bu ağlar, konteynerlerin birbirleriyle iletişim kurmalarına ve belirli servislerin belirli ağlarda çalışmalarına olanak tanır. Bu, özellikle güvenlik veya performans gereksinimlerini karşılamak için farklı ağ segmentlerinde çalışan servisleri izole etmek istediğiniz durumlarda kullanışlıdır.

Aşağıdaki komutla, konfigürasyonlarını tamamladığımız servisleri ayağa kaldırabilirsiniz.

docker-compose up -d

Artık tarayıcınızı açabilir ve http://localhost:8080 adresine giderek PHP uygulamanızı görebilirsiniz. phpMyAdmin arayüzüne http://localhost:8081/ adresinden erişebilirsiniz.

tnrdll

C++ string

C++ dilinde std::string sınıfı, metin verilerini temsil etmek için kullanılır. Bu sınıf, bir dizi karakteri yönetir ve bir dizi metot içerir. 

#include <iostream>
#include <string>

int main() {
    // String oluşturma ve başlatma
    std::string myString = "Merhaba, Dünya!";

    // String'i ekrana yazdırma
    std::cout << "myString: " << myString << std::endl;

    // String'in uzunluğunu elde etme
    std::cout << "Uzunluk: " << myString.length() << std::endl;

    // String'in boş olup olmadığını kontrol etme
    if (myString.empty()) {
        std::cout << "String boş." << std::endl;
    } else {
        std::cout << "String boş değil." << std::endl;
    }

    // String'in belirli bir konumundan bir alt dizi elde etme
    std::string altDizi = myString.substr(8, 5);
    std::cout << "Alt Dizi: " << altDizi << std::endl;

    // String'e başka bir string ekleme
    myString += " Nasılsınız?";
    std::cout << "myString (Güncellenmiş): " << myString << std::endl;

    // String'i karşılaştırma
    std::string digerString = "Merhaba, Dünya!";
    if (myString == digerString) {
        std::cout << "İki string eşit." << std::endl;
    } else {
        std::cout << "İki string eşit değil." << std::endl;
    }

    return 0;
}

Bu örnek, std::string sınıfının bazı temel özelliklerini göstermektedir. String oluşturma, ekrana yazdırma, uzunluk kontrolü, boş olup olmadığını kontrol etme, alt dizi oluşturma, string birleştirme ve string karşılaştırma gibi işlemler örnekte bulunmaktadır.

C++ dilinde std::string sınıfı, bir dizi kullanışlı fonksiyon içerir. 

std::string myString = "Merhaba";
std::cout << "Uzunluk: " << myString.length() << std::endl;

C++ dilinde std::string sınıfı, bir dizi kullanışlı fonksiyon içerir.

length() / size(): String’in uzunluğunu döndürür.

std::string myString = "Merhaba";
std::cout << "Uzunluk: " << myString.length() << std::endl;

empty(): String’in boş olup olmadığını kontrol eder.

if (myString.empty()) {
    std::cout << "String boş." << std::endl;
}

clear(): String’i boşaltır.

myString.clear();

append() / +=: Bir string’i diğerine ekler.

myString += "Dünya";
// veya
myString.append("Dünya");

substr(): Belirli bir konumdan itibaren veya belirli bir uzunluktaki bir alt dizi oluşturur.

std::string altDizi = myString.substr(3, 4); // 3. indeksten başlayarak 4 karakter alır.

find(): Belirli bir alt diziyi arar ve bulunduğu indeksi döndürür.

size_t pozisyon = myString.find("haba");
if (pozisyon != std::string::npos) {
    std::cout << "Alt dizi bulundu, pozisyon: " << pozisyon << std::endl;
} else {
    std::cout << "Alt dizi bulunamadı." << std::endl;
}

replace(): Belirli bir bölümü başka bir string ile değiştirir.

myString.replace(0, 3, "Selam"); // 0. indeksten başlayarak 3 karakteri "Selam" ile değiştirir.

c_str(): String’i C-style null-terminated bir karakter dizisine dönüştürür.

const char* cString = myString.c_str();

compare(): İki string’i karşılaştırır.

if (myString.compare("Merhaba") == 0) {
    std::cout << "İki string eşit." << std::endl;
} else {
    std::cout << "İki string eşit değil." << std::endl;
}

tnrdll

C++ vektör ve liste farkları

C++ dilinde vektör ve liste, iki farklı veri yapısıdır ve her birinin avantajları ve dezavantajları vardır. İşlevsellikleri benzer olsa da, içerdikleri veri yapıları ve performans karakteristikleri farklıdır.

C++ vektör ve liste arasındaki bazı temel farklar:

  1. Veri Yapısı:
  • Vektör (Vector): Dinamik bir dizi olarak çalışır. Bellekte ardışık olarak depolanan bir dizi elemandan oluşur.
  • Liste (List): Çift yönlü bağlı liste olarak çalışır. Her bir eleman, kendisinden önceki ve sonraki elemanı işaret eden bağlantılara sahiptir.
  1. Bellek Yerleşimi:
  • Vektör: Elemanlar ardışık bellek bölgelerine saklanır, bu nedenle elemanlara doğrudan erişim daha hızlıdır.
  • Liste: Her eleman, bağlı olduğu önceki ve sonraki elemanları gösteren işaretçilere sahiptir, bu nedenle rastgele erişim daha yavaş olabilir.
  1. Ekleme ve Silme İşlemleri:
  • Vektör: Eleman eklemek veya çıkarmak maliyetli olabilir, çünkü bu işlemler ardışık bellek bölgelerinde yapıldığından, elemanların taşınması gerekebilir.
  • Liste: Ekleme ve çıkarma işlemleri daha hızlıdır çünkü sadece bağlantıları güncellemek yeterlidir. Ancak, rastgele erişim daha yavaş olabilir.
  1. İterasyon (Döngü) Performansı:
  • Vektör: Ardışık bellek bölgelerinde depolandığı için, elemanlara doğrudan erişim sağlamak için daha etkilidir.
  • Liste: Her elemanın bağlı olduğu önceki ve sonraki elemanları takip etmek için dolaşmak gerektiğinden dolayı vektörden daha yavaş olabilir.
  1. Bellek Kullanımı:
  • Vektör: Bellek kullanımı daha etkin olabilir çünkü elemanlar ardışık bellek bölgelerinde depolanır.
  • Liste: Her elemanın bağlantıları için ek bellek kullanımı gerektiği için, vektöre kıyasla daha fazla bellek kullanabilir.

Hangi veri yapısının kullanılacağı, uygulama ihtiyaçlarına ve yapılan işlemlerin türüne bağlıdır. Genel olarak, vektör rastgele erişim ve bellek etkinliği gerektiren durumlar için daha uygundur, while liste özellikle sık ekleme ve çıkarma işlemleri gerektiren durumlar için daha uygundur.

tnrdll

C++ listeler

C++ programlamada, std::list başlık dosyası #include <list> ile dahil edilen ve çift yönlü bağlı liste (doubly linked list) veri yapısını temsil eden bir STL (Standard Template Library) sınıfıdır. Bu sınıf, birçok işlemi hızlı bir şekilde gerçekleştirmek için kullanışlıdır, ancak elemanlara doğrudan erişim yapmak dizilere kıyasla daha yavaştır.

  1. std::list Tanımlama:
#include <iostream>
#include <list>

int main() {
    std::list<int> myList;
    return 0;
}
  1. Eleman Ekleme:
myList.push_back(42); // Liste sonuna eleman ekler
myList.push_front(10); // Liste başına eleman ekler
  1. Eleman Silme:
myList.pop_back(); // Liste sonundaki elemanı siler
myList.pop_front(); // Liste başındaki elemanı siler
  1. Elemanları Dolaşma:
for (const int& item : myList) {
    std::cout << item << " ";
}
  1. Eleman Sayısı:
int size = myList.size(); // Listenin eleman sayısını alır
  1. Eleman Arama:
auto it = std::find(myList.begin(), myList.end(), 42); // 42 elemanını arar
if (it != myList.end()) {
    std::cout << "42 found in the list." << std::endl;
}
  1. Liste Temizleme:
myList.clear(); // Listeyi temizler, tüm elemanlar silinir

Not: std::list kullanımı, elemanlara hızlı bir şekilde ekleme ve silme gereksinimlerini karşılamak için uygundur, ancak elemanlara rasgele erişim gereksinimleri varsa std::vector veya std::array kullanmayı düşünebilirsiniz.