Takip et

How to use the string find() in C++

Giriş C++’ın standart kütüphanesi, dizelerle (string) çalışmayı kolaylaştıran güçlü araçlar sunar. Bu araçlardan biri de std::string:

Giriş

C++’ın standart kütüphanesi, dizelerle (string) çalışmayı kolaylaştıran güçlü araçlar sunar. Bu araçlardan biri de std::string::find() fonksiyonudur. Bu fonksiyon, bir dize içinde belirli bir alt dizeyi veya karakteri aramanızı sağlar. Metin işleme, veri ayrıştırma, dosya içeriklerini analiz etme gibi birçok senaryoda vazgeçilmez bir yardımcıdır. Bu rehberde, std::string::find() fonksiyonunun nasıl kullanılacağını, farklı varyasyonlarını, pratik örneklerini ve gelişmiş ipuçlarını detaylı bir şekilde inceleyeceğiz.

std::string::find() Fonksiyonuna Derinlemesine Bakış

std::string::find() fonksiyonu, bir std::string nesnesi içinde başka bir dizeyi veya karakteri aramak için kullanılır. Eğer aranan öğe bulunursa, bulunduğu ilk konumun (indeksin) başlangıcını döndürür. Bulunamazsa, özel bir değer olan std::string::npos döndürür.

Fonksiyon Aşırı Yüklemeleri (Overloads)

find() fonksiyonunun birkaç aşırı yüklemesi (overload) bulunur, bu da onu farklı arama senaryolarına uygun hale getirir:

  1. size_type find(const basic_string& str, size_type pos = 0) const;
    Bu en yaygın kullanımdır. Belirli bir std::string nesnesini (str) arar. Arama, pos parametresiyle belirtilen indeksten başlar (varsayılan olarak 0, yani dizenin başından).
  2. size_type find(const CharT* s, size_type pos = 0) const;
    Bu aşırı yükleme, C-stili bir dizeyi (const char* s) aramak için kullanılır. Arama yine pos parametresiyle belirtilen indeksten başlar.
  3. size_type find(const CharT* s, size_type pos, size_type n) const;
    Bu versiyon, C-stili bir dizenin (const char* s) ilk n karakterini arar. Arama pos parametresiyle belirtilen indeksten başlar. Bu, C-stili dizenin tamamını değil, sadece bir kısmını aramak istediğinizde kullanışlıdır.
  4. size_type find(CharT ch, size_type pos = 0) const;
    Tek bir karakteri (ch) aramak için kullanılır. Arama, pos parametresiyle belirtilen indeksten başlar.

Parametreler

  • str: Aranacak std::string nesnesi.
  • s: Aranacak C-stili dize (const char*).
  • ch: Aranacak karakter.
  • pos: Arama işleminin başlayacağı başlangıç indeksi. Varsayılan değeri 0’dır, yani dizenin başından başlar.
  • n: s parametresiyle verilen C-stili dizenin kaç karakterinin aranacağını belirtir.

Dönüş Değeri

Tüm find() aşırı yüklemeleri, size_type türünde bir değer döndürür. Bu değer:

  • Eğer aranan öğe bulunursa, bulunduğu ilk karakterin indeksidir.
  • Eğer aranan öğe bulunamazsa, std::string::npos değeridir.

std::string::npos, std::string sınıfının statik bir üyesidir ve genellikle mümkün olan en büyük size_type değeridir. Bu değeri, bir arama sonucunun başarısız olduğunu anlamak için kontrol etmeniz kritik öneme sahiptir.

Temel Kullanım Senaryoları ve Kod Örnekleri

Alt Dize Arama

Bir dize içinde belirli bir alt dizeyi aramak en yaygın kullanım şeklidir.


#include 
#include 

int main() {
    std::string metin = "Merhaba dünya, C++ programlama çok güzel.";
    std::string aranan = "C++";

    size_t konum = metin.find(aranan);

    if (konum != std::string::npos) {
        std::cout << "'" << aranan << "' alt dizesi " << konum 
                  << " indeksinde bulundu." << std::endl;
    } else {
        std::cout << "'" << aranan << "' alt dizesi bulunamadı." << std::endl;
    }

    aranan = "Java";
    konum = metin.find(aranan);

    if (konum != std::string::npos) {
        std::cout << "'" << aranan << "' alt dizesi " << konum 
                  << " indeksinde bulundu." << std::endl;
    } else {
        std::cout << "'" << aranan << "' alt dizesi bulunamadı." << std::endl;
    }

    return 0;
}

Çıktı:


'C++' alt dizesi 15 indeksinde bulundu.
'Java' alt dizesi bulunamadı.

Karakter Arama

Tek bir karakteri aramak da oldukça basittir.


#include 
#include 

int main() {
    std::string cumle = "Bu bir deneme cümlesidir.";
    char arananKarakter = 'e';

    size_t konum = cumle.find(arananKarakter);

    if (konum != std::string::npos) {
        std::cout << "'" << arananKarakter << "' karakteri " << konum 
                  << " indeksinde bulundu." << std::endl;
    } else {
        std::cout << "'" << arananKarakter << "' karakteri bulunamadı." << std::endl;
    }
    return 0;
}

Çıktı:


'e' karakteri 5 indeksinde bulundu.

Belirli Bir Konumdan Başlayarak Arama

pos parametresini kullanarak aramanın başlayacağı yeri belirleyebilirsiniz. Bu, özellikle bir dizedeki aynı alt dizenin veya karakterin birden fazla tekrarını bulmak istediğinizde kullanışlıdır.


#include 
#include 

int main() {
    std::string veri = "elma, armut, elma, muz, elma";
    std::string aranan = "elma";
    size_t baslangicKonumu = 0;

    // İlk 'elma'yı bul
    size_t ilkElma = veri.find(aranan, baslangicKonumu);
    if (ilkElma != std::string::npos) {
        std::cout << "İlk '" << aranan << "' " << ilkElma 
                  << " indeksinde bulundu." << std::endl;
        // İkinci 'elma'yı bulmak için ilk bulunan konumdan sonraki karakterden başla
        size_t ikinciElma = veri.find(aranan, ilkElma + 1);
        if (ikinciElma != std::string::npos) {
            std::cout << "İkinci '" << aranan << "' " << ikinciElma 
                      << " indeksinde bulundu." << std::endl;
        } else {
            std::cout << "İkinci '" << aranan << "' bulunamadı." << std::endl;
        }
    }
    return 0;
}

Çıktı:


İlk 'elma' 0 indeksinde bulundu.
İkinci 'elma' 13 indeksinde bulundu.

C-Stili Dizelerle Arama

const char* türündeki C-stili dizeleri de find() ile arayabilirsiniz.


#include 
#include 

int main() {
    std::string dosyaYolu = "/usr/local/bin/uygulama";
    const char* arananDizin = "/bin";

    size_t konum = dosyaYolu.find(arananDizin);

    if (konum != std::string::npos) {
        std::cout << "'" << arananDizin << "' alt dizesi " << konum 
                  << " indeksinde bulundu." << std::endl;
    } else {
        std::cout << "'" << arananDizin << "' alt dizesi bulunamadı." << std::endl;
    }

    // Sadece C-stili dizenin bir kısmını arama
    const char* uzunDize = "programlama";
    size_t parcaKonum = dosyaYolu.find(uzunDize, 0, 3); // "pro" kısmını arar

    if (parcaKonum != std::string::npos) {
        std::cout << "Uzun dizenin 'pro' kısmı " << parcaKonum 
                  << " indeksinde bulundu." << std::endl;
    } else {
        std::cout << "Uzun dizenin 'pro' kısmı bulunamadı." << std::endl;
    }

    return 0;
}

Çıktı:


'/bin' alt dizesi 10 indeksinde bulundu.
Uzun dizenin 'pro' kısmı bulunamadı.

Not: İkinci arama "programlama"nın "pro" kısmını arıyor ancak "dosyaYolu" dizesinde "pro" geçmediği için bulunamıyor. Bu, n parametresinin nasıl çalıştığını gösterir.

Gelişmiş Kullanım ve Pratik İpuçları

Tüm Tekrarları Bulma

Bir dize içindeki belirli bir alt dizenin veya karakterin tüm tekrarlarını bulmak için find() fonksiyonunu bir döngü içinde kullanabilirsiniz.


#include 
#include 
#include 

int main() {
    std::string metin = "banana, elma, banana, portakal, banana";
    std::string aranan = "banana";
    size_t konum = metin.find(aranan, 0); // Aramaya baştan başla
    std::vector bulunanKonumlar;

    while (konum != std::string::npos) {
        bulunanKonumlar.push_back(konum);
        // Bir sonraki aramaya, bulunan konumdan sonraki karakterden başla
        konum = metin.find(aranan, konum + aranan.length()); 
    }

    if (!bulunanKonumlar.empty()) {
        std::cout << "'" << aranan << "' alt dizesi şu konumlarda bulundu: ";
        for (size_t idx : bulunanKonumlar) {
            std::cout << idx << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "'" << aranan << "' alt dizesi bulunamadı." << std::endl;
    }
    return 0;
}

Çıktı:


'banana' alt dizesi şu konumlarda bulundu: 0 14 32 

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

std::string::find() fonksiyonu büyük/küçük harf duyarlıdır. Yani "Elma" ile "elma" farklı olarak algılanır. Eğer büyük/küçük harf duyarsız bir arama yapmak istiyorsanız, arama yapmadan önce her iki dizeyi de (hem ana dizeyi hem de aranacak dizeyi) aynı duruma (örneğin, hepsi küçük harf veya hepsi büyük harf) dönüştürmeniz gerekir. Bunun için std::transform ve std::tolower/std::toupper gibi fonksiyonlar kullanılabilir.


// KAVRAMSAL ÖRNEK (tam kod değil)
// std::string kucukHarfMetin = metin;
// std::transform(kucukHarfMetin.begin(), kucukHarfMetin.end(), kucukHarfMetin.begin(), ::tolower);
// std::string kucukHarfAranan = aranan;
// std::transform(kucukHarfAranan.begin(), kucukHarfAranan.end(), kucukHarfAranan.begin(), ::tolower);
// size_t konum = kucukHarfMetin.find(kucukHarfAranan);

Performans Notları

std::string::find() fonksiyonunun karmaşıklığı, en kötü durumda, ana dizenin uzunluğu ile aranan alt dizenin uzunluğunun çarpımı kadardır (O(N*M)). Çoğu modern C++ uygulamasında bu yeterince hızlıdır. Ancak çok büyük metinler üzerinde çok sayıda arama yapmanız gerektiğinde veya karmaşık desenler aradığınızda, düzenli ifadeler (regular expressions) veya daha gelişmiş dize arama algoritmaları (örneğin, Knuth-Morris-Pratt veya Boyer-Moore) kullanmayı düşünebilirsiniz.

Alternatifler

find() dışında, std::string sınıfının başka arama fonksiyonları da mevcuttur:

  • rfind(): Dizinin sonundan başlayarak arama yapar.
  • find_first_of(): Belirtilen karakterlerden herhangi birinin ilk geçtiği yeri bulur.
  • find_last_of(): Belirtilen karakterlerden herhangi birinin son geçtiği yeri bulur.
  • find_first_not_of(): Belirtilen karakterlerden hiçbiri olmayan ilk karakteri bulur.
  • find_last_not_of(): Belirtilen karakterlerden hiçbiri olmayan son karakteri bulur.

Daha karmaşık desen eşleştirme için C++11 ile gelen kütüphanesini kullanabilirsiniz.

Sonuç ve Sıkça Sorulan Sorular (SSS)

std::string::find(), C++'ta dize manipülasyonunun temel taşlarından biridir. Basit alt dize ve karakter aramalarından, tüm tekrarları bulmaya kadar geniş bir kullanım alanına sahiptir. Dönüş değeri olan std::string::npos'u doğru bir şekilde kontrol etmek, başarılı ve hatasız kod yazmak için hayati öneme sahiptir. Büyük/küçük harf duyarlılığı gibi özelliklerini bilmek ve gerektiğinde alternatif algoritmaları değerlendirmek, daha verimli ve sağlam uygulamalar geliştirmenize yardımcı olacaktır.

SSS (Sıkça Sorulan Sorular)

1. find() ile rfind() arasındaki fark nedir?
find() aramaya dizenin başından (solundan) başlar ve ilk eşleşmeyi döndürür. rfind() ise aramaya dizenin sonundan (sağından) başlar ve ilk eşleşmeyi (yani dizenin en sağındaki eşleşmeyi) döndürür.

2. find() büyük/küçük harf duyarlı mıdır?
Evet, std::string::find() büyük/küçük harf duyarlıdır. "Merhaba" ve "merhaba" farklı dizeler olarak kabul edilir. Duyarsız arama yapmak için her iki dizeyi de arama öncesinde aynı duruma dönüştürmeniz gerekir.

3. std::string::npos nedir?
std::string::npos, find() fonksiyonu aranan alt dizeyi veya karakteri bulamadığında döndürülen özel bir değerdir. Genellikle size_t türünün maksimum değerine eşittir.

4. Bir dizedeki tüm tekrarları nasıl bulurum?
find() fonksiyonunu bir döngü içinde, her başarılı aramadan sonra pos parametresini bulunan konumun hemen sonrasına (konum + aranan.length()) ayarlayarak kullanabilirsiniz. Yukarıdaki "Tüm Tekrarları Bulma" örneğine bakınız.

5. find() yerine ne zaman regex kullanmalıyım?
Eğer arama deseniniz karmaşıksa (örneğin, belirli bir formatta e-posta adresleri, telefon numaraları, dinamik desenler) veya daha gelişmiş desen eşleştirme (yakalama grupları, tekrarlar, alternatifler) özelliklerine ihtiyacınız varsa, kütüphanesini kullanmak daha uygun olacaktır. Basit alt dize veya karakter aramaları için find() çok daha hızlı ve yeterlidir.

Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.