C++ programlamada string (metin dizisi) karşılaştırmaları, neredeyse her uygulamada karşılaşılan temel bir işlemdir. Kullanıcı girişlerini doğrulamaktan, veritabanı sorgularını filtrelemeye, dosya yollarını kontrol etmeye kadar birçok senaryoda string’leri doğru ve verimli bir şekilde karşılaştırmak büyük önem taşır. C++, bu ihtiyacı karşılamak için birden fazla yöntem sunar. Bu rehberde, C++’da string karşılaştırması yapmanın üç ana yolunu, kod örnekleriyle ve pratik bilgilerle detaylı bir şekilde inceleyeceğiz.
Bu yöntemler, özellikle modern C++’da sıklıkla kullanılan std::string sınıfı ve daha geleneksel C-stili karakter dizileri (char*) için geçerlidir. Her yöntemin kendine özgü avantajları ve kullanım durumları vardır. Hangi yöntemin sizin için en uygun olduğunu anlamak, daha temiz, daha güvenli ve daha performanslı kod yazmanıza yardımcı olacaktır.
1. Yöntem: Karşılaştırma Operatörleri (==, !=, <, >, <=, >=)
C++'ın std::string sınıfı, string karşılaştırmalarını son derece sezgisel ve okunabilir hale getiren standart karşılaştırma operatörlerini (==, !=, <, >, <=, >=) aşırı yüklemiştir. Bu operatörler, std::string nesnelerini doğrudan birbirleriyle veya C-stili string'lerle karşılaştırmak için kullanılabilir.
Eşitlik ve Eşitsizlik Karşılaştırmaları
== operatörü, iki string'in tam olarak aynı karaktere sahip olup olmadığını kontrol eder. != operatörü ise tam tersini, yani iki string'in farklı olup olmadığını kontrol eder. Bu karşılaştırmalar, büyük/küçük harf duyarlıdır.
#include
#include
int main() {
std::string s1 = "Merhaba Dunya";
std::string s2 = "Merhaba Dunya";
std::string s3 = "merhaba dunya";
std::string s4 = "C++";
// Eşitlik kontrolü
if (s1 == s2) {
std::cout << "s1 ve s2 aynıdır." << std::endl; // Bu çalışır
}
if (s1 == s3) {
std::cout << "s1 ve s3 aynıdır." << std::endl; // Bu çalışmaz (büyük/küçük harf farkı)
} else {
std::cout << "s1 ve s3 farklıdır (büyük/küçük harf duyarlı)." << std::endl;
}
// Eşitsizlik kontrolü
if (s1 != s4) {
std::cout << "s1 ve s4 farklıdır." << std::endl; // Bu çalışır
}
// C-stili string ile karşılaştırma
const char* c_str = "Merhaba Dunya";
if (s1 == c_str) {
std::cout << "s1 ve C-stili string aynıdır." << std::endl; // Bu çalışır
}
return 0;
}
Sözcüksel (Lexicographical) Karşılaştırmalar
<, >, <=, >= operatörleri, string'leri sözcüksel olarak (alfabetik sıraya göre) karşılaştırır. Bu, sözlükteki kelimelerin sıralanma şekline benzer. Karakterlerin ASCII veya Unicode değerleri esas alınarak soldan sağa doğru karşılaştırma yapılır. İlk farklı karakterde, karakterin sayısal değeri daha küçük olan string "daha küçük" kabul edilir.
#include
#include
int main() {
std::string s1 = "apple";
std::string s2 = "banana";
std::string s3 = "Apple"; // 'A' < 'a'
std::string s4 = "apple pie";
if (s1 < s2) {
std::cout << "s1 (apple) s2'den (banana) küçüktür." << std::endl; // Bu çalışır
}
if (s1 > s3) {
std::cout << "s1 (apple) s3'ten (Apple) büyüktür." << std::endl; // Bu çalışır çünkü 'a' > 'A'
}
if (s1 < s4) {
std::cout << "s1 (apple) s4'ten (apple pie) küçüktür." << std::endl; // Bu çalışır (s4 daha uzundur)
}
return 0;
}
Pratik Bilgi: Karşılaştırma operatörleri, std::string nesneleri için genellikle tercih edilen yöntemdir çünkü okunabilirlikleri yüksektir ve derleyici tarafından iyi optimize edilmişlerdir. Çoğu temel string karşılaştırma ihtiyacını karşılarlar.
2. Yöntem: std::string::compare() Metodu
std::string sınıfının compare() metodu, karşılaştırma operatörlerinden daha fazla esneklik sunar. Bu metodun çeşitli aşırı yüklenmiş versiyonları bulunur, bu da belirli bir bölümü veya belirli bir uzunluktaki string'leri karşılaştırma imkanı tanır.
compare() Metodunun Genel Kullanımı
int std::string::compare(const std::string& str) const;
Bu temel versiyon, çağrılan string nesnesini parametre olarak verilen string ile karşılaştırır. Geri dönüş değeri şunları ifade eder:
0: İki string tamamen aynıdır.< 0: Çağrılan string, parametre string'inden sözcüksel olarak daha küçüktür.> 0: Çağrılan string, parametre string'inden sözcüksel olarak daha büyüktür.
#include
#include
int main() {
std::string s1 = "elma";
std::string s2 = "elma";
std::string s3 = "armut";
int result1 = s1.compare(s2);
if (result1 == 0) {
std::cout << "s1 ve s2 aynıdır (compare metodu)." << std::endl; // Bu çalışır
}
int result2 = s1.compare(s3);
if (result2 < 0) {
std::cout << "s1 (elma) s3'ten (armut) küçüktür (compare metodu)." << std::endl; // Bu çalışır
}
return 0;
}
Alt String Karşılaştırmaları
compare() metodunun en güçlü yanlarından biri, string'lerin belirli bölümlerini karşılaştırabilmesidir. Bu, string'in bir kısmının başka bir string'in bir kısmıyla eşleşip eşleşmediğini kontrol etmek istediğinizde çok kullanışlıdır.
int std::string::compare(size_type pos, size_type len, const std::string& str) const;
Bu versiyon, çağıran string'in pos konumundan başlayarak len uzunluğundaki alt string'ini str ile karşılaştırır.
int std::string::compare(size_type pos, size_type len, const std::string& str, size_type subpos, size_type sublen) const;
Bu en kapsamlı versiyon, çağıran string'in pos konumundan başlayarak len uzunluğundaki alt string'ini, parametre str'nin subpos konumundan başlayarak sublen uzunluğundaki alt string'i ile karşılaştırır.
#include
#include
int main() {
std::string full_str = "Bu bir test stringidir.";
std::string part_str = "test";
std::string another_str = "Bu bir deneme metnidir.";
// full_str'nin 7. konumundan itibaren 4 karakteri part_str ile karşılaştır
// "test" == "test"
if (full_str.compare(7, 4, part_str) == 0) {
std::cout << "'test' alt stringi bulundu." << std::endl; // Bu çalışır
}
// full_str'nin 0. konumundan itibaren 5 karakteri ("Bu bi")
// another_str'nin 0. konumundan itibaren 5 karakteri ("Bu bi") ile karşılaştır
if (full_str.compare(0, 5, another_str, 0, 5) == 0) {
std::cout << "İki stringin ilk 5 karakteri aynıdır." << std::endl; // Bu çalışır
}
return 0;
}
Pratik Bilgi: compare() metodu, özellikle string'lerin tamamını değil, belirli bölümlerini karşılaştırmanız gerektiğinde veya karşılaştırma sonucunun tam sayı olarak (0, <0, >0) alınması gereken algoritmalar geliştirirken çok faydalıdır. Karşılaştırma operatörlerinden daha az okunabilir olabilir, ancak daha fazla kontrol sağlar.
3. Yöntem: C-Stili String Fonksiyonları (strcmp, strncmp)
C++'da std::string sınıfı modern string yönetimi için tercih edilse de, C dilinden miras kalan C-stili string'ler (char*) ve bunlarla çalışan fonksiyonlar hala kullanılmaktadır. Özellikle eski C kodlarıyla etkileşim kurarken veya belirli düşük seviyeli performans optimizasyonları gerektiğinde bu fonksiyonlar devreye girebilir. Bu fonksiyonlar
Önemli Not: C-stili string fonksiyonları, string'lerin null ile sonlandırılmış (\0) olmasını bekler. std::string nesneleriyle kullanırken, c_str() metodunu kullanarak null ile sonlandırılmış bir char* pointer'ı elde etmelisiniz.
strcmp() Fonksiyonu
int strcmp(const char str1, const char str2);
strcmp() fonksiyonu, iki null ile sonlandırılmış C-stili string'i sözcüksel olarak karşılaştırır. Geri dönüş değeri std::string::compare() metodu ile aynıdır:
0: İki string aynıdır.< 0:str1,str2'den küçüktür.> 0:str1,str2'den büyüktür.
Bu fonksiyon da büyük/küçük harf duyarlıdır.
#include
#include // std::string için
#include // strcmp için
int main() {
const char* c_str1 = "Kedi";
const char* c_str2 = "Kedi";
const char* c_str3 = "Kopek";
// C-stili string'leri doğrudan karşılaştırma
if (strcmp(c_str1, c_str2) == 0) {
std::cout << "c_str1 ve c_str2 aynıdır (strcmp)." << std::endl; // Bu çalışır
}
if (strcmp(c_str1, c_str3) < 0) {
std::cout << "c_str1 (Kedi) c_str3'ten (Kopek) küçüktür (strcmp)." << std::endl; // Bu çalışır
}
// std::string nesnelerini strcmp ile karşılaştırma (c_str() kullanarak)
std::string s1 = "Elma";
std::string s2 = "Armut";
if (strcmp(s1.c_str(), s2.c_str()) < 0) {
std::cout << "s1 (Elma) s2'den (Armut) küçüktür (strcmp ile std::string)." << std::endl; // Bu çalışır
}
return 0;
}
strncmp() Fonksiyonu
int strncmp(const char str1, const char str2, size_t n);
strncmp() fonksiyonu, strcmp()'a benzer ancak string'lerin yalnızca ilk n karakterini karşılaştırır. Bu, özellikle string'lerin belirli bir önekini (prefix) karşılaştırmak istediğinizde veya buffer taşmasını önlemek için string'in maksimum uzunluğunu bildiğinizde kullanışlıdır.
#include
#include
#include
int main() {
const char* c_str1 = "programlama";
const char* c_str2 = "programci";
const char* c_str3 = "program";
// İlk 7 karakteri karşılaştır: "program" == "program"
if (strncmp(c_str1, c_str2, 7) == 0) {
std::cout << "c_str1 ve c_str2'nin ilk 7 karakteri aynıdır (program)." << std::endl; // Bu çalışır
}
// c_str1'in tamamını c_str3 ile karşılaştır
if (strncmp(c_str1, c_str3, strlen(c_str3)) == 0) {
std::cout << "c_str1, c_str3 ile başlıyor." << std::endl; // Bu çalışır
}
// std::string ile strncmp kullanımı
std::string s1 = "Dosya.txt";
std::string s2 = "Dizin.log";
if (strncmp(s1.c_str(), s2.c_str(), 1) == 0) { // İlk karakter 'D'
std::cout << "s1 ve s2'nin ilk karakteri aynıdır." << std::endl; // Bu çalışır
}
return 0;
}
Pratik Bilgi: strcmp ve strncmp fonksiyonları, özellikle performans kritik uygulamalarda ve C-stili string'lerle çalışırken kullanılabilir. Ancak std::string nesneleriyle çalışırken, c_str() çağrısı bir miktar overhead getirebilir. Güvenlik açısından, strncmp genellikle strcmp'a tercih edilir çünkü buffer taşması riskini azaltır. Modern C++'da genellikle std::string operatörleri veya compare() metodu tercih edilmelidir.
Pratik İpuçları ve Performans Değerlendirmeleri
Büyük/Küçük Harf Duyarsız Karşılaştırma
Yukarıda bahsedilen tüm karşılaştırma yöntemleri varsayılan olarak büyük/küçük harf duyarlıdır. Eğer büyük/küçük harf duyarsız bir karşılaştırma yapmanız gerekiyorsa, string'leri karşılaştırmadan önce geçici olarak tek bir duruma (genellikle küçük harfe) dönüştürmeniz gerekir. Bunun için
#include
#include
#include // std::transform için
#include // std::tolower için
// Bir string'i küçük harfe dönüştüren yardımcı fonksiyon
std::string toLower(std::string s) {
std::transform(s.begin(), s.end(), s.begin(),
[](unsigned char c){ return std::tolower(c); });
return s;
}
int main() {
std::string s1 = "Merhaba";
std::string s2 = "merhaba";
if (toLower(s1) == toLower(s2)) {
std::cout << "s1 ve s2 büyük/küçük harf duyarsız olarak aynıdır." << std::endl; // Bu çalışır
}
return 0;
}
Bu yöntem, her iki string için de yeni geçici string'ler oluşturduğu için performans maliyeti getirebilir. Daha performanslı bir alternatif, iki string'i karakter karakter karşılaştırırken her karakteri anında dönüştürmektir. Ancak bu, kodun okunabilirliğini düşürebilir.
Locale-Specific Karşılaştırmalar
Bazı dillerde (örneğin Türkçe'de 'i' ve 'İ' gibi), karakter sıralaması veya büyük/küçük harf dönüşümleri varsayılan ASCII/Unicode kurallarından farklı olabilir. Standart karşılaştırma operatörleri ve compare() metodu genellikle temel Unicode sıralamasını takip eder. Daha karmaşık, dile özel (locale-specific) karşılaştırmalar için C++'ın std::locale ve std::collate fasetlerini kullanmanız gerekebilir. Ancak bu, ileri düzey bir konudur ve çoğu uygulama için gerekli değildir.
Performans Değerlendirmeleri
std::stringOperatörleri (==,<vb.): Çoğu durumda,std::stringoperatörleri en iyi seçenektir. Hem okunabilirdirler hem de modern C++ derleyicileri ve kütüphaneleri tarafından iyi optimize edilmişlerdir. Genellikle dahili olarak string'in uzunluğunu kontrol eder ve ardından karakter karakter karşılaştırma yapar.std::string::compare(): Alt string karşılaştırmaları veya belirli uzunlukta karşılaştırmalar gerektiğinde performansı artırabilir, çünkü gereksiz yere string'in tamamını kopyalamadan veya dönüştürmeden doğrudan işlem yapar. Temel karşılaştırmalarda operatörlerle benzer performansa sahiptir.strcmp/strncmp: C-stili string'lerle çalışırken veyastd::string::c_str()ile kullanıldığında performansları iyidir. Ancakstd::string'denchar*'a dönüşümün (c_str()) bir maliyeti olabilir. Düşük seviyeli optimizasyonlar için düşünülebilirler, ancak genelliklestd::stringyöntemleri daha güvenli ve yeterince hızlıdır.strncmpözellikle büyük string'lerde yalnızca küçük bir kısmını karşılaştırmak gerektiğindestrcmp'tan daha hızlı olabilir.
Genel kural olarak, okunabilirlik ve güvenliği ön planda tutarak std::string operatörlerini veya compare() metodunu tercih edin. Performans sorunları yaşadığınızda ve profil oluşturma (profiling) araçlarıyla darboğazın string karşılaştırmalarında olduğunu tespit ettiğinizde, diğer yöntemleri veya daha düşük seviyeli optimizasyonları düşünün.
Sonuç ve Sıkça Sorulan Sorular (SSS)
C++'da string karşılaştırmaları için üç temel yöntem bulunmaktadır: std::string karşılaştırma operatörleri, std::string::compare() metodu ve C-stili strcmp/strncmp fonksiyonları. Her birinin kendine özgü kullanım alanları ve avantajları vardır:
- Karşılaştırma Operatörleri (
==,!=,<,>): En okunabilir ve genellikle tercih edilen yöntemdir. Basit eşitlik, eşitsizlik ve sözcüksel sıralama için idealdir. std::string::compare()Metodu: Alt string karşılaştırmaları, belirli uzunlukta karşılaştırmalar ve karşılaştırma sonucunun tam sayı olarak alınması gereken durumlar için daha fazla kontrol ve esneklik sunar.strcmp/strncmpFonksiyonları: C-stili string'lerle çalışırken veyastd::string::c_str()ile kullanıldığında geçerlidir. Performans kritik senaryolarda veya eski C kodlarıyla entegrasyonda düşünülebilir, ancak güvenlik riskleri vestd::string'e kıyasla daha az esneklik içerir.
Modern C++'da, std::string sınıfının sunduğu yöntemler (operatörler ve compare()) genellikle en güvenli, en okunabilir ve yeterince performanslı çözümleri sunar. C-stili fonksiyonları kullanırken null pointer kontrolleri ve buffer boyutlarına dikkat etmek hayati önem taşır.
Sıkça Sorulan Sorular (SSS)
S: std::string karşılaştırmaları büyük/küçük harf duyarlı mıdır?
C: Evet, varsayılan olarak std::string karşılaştırmaları (operatörler ve compare() metodu dahil) büyük/küçük harf duyarlıdır. Büyük/küçük harf duyarsız karşılaştırma için string'leri önce tek bir duruma (örneğin küçük harfe) dönüştürmeniz gerekir.
S: Hangi string karşılaştırma yöntemi en hızlıdır?
C: Genel olarak, std::string operatörleri ve compare() metodu, derleyiciler ve kütüphaneler tarafından oldukça optimize edilmiştir ve çoğu durumda yeterince hızlıdır. strcmp/strncmp C-stili string'ler için çok hızlı olsa da, std::string nesneleriyle kullanıldığında c_str() çağrısının bir maliyeti olabilir. Performans, string'lerin uzunluğuna, içeriklerine ve kullanılan CPU mimarisine göre değişebilir. Kodu optimize etmeden önce bir profilleyici ile performans darboğazlarını tespit etmek her zaman en iyi yaklaşımdır.
S: char* ile std::string karşılaştırabilir miyim?
C: Evet, std::string operatörleri ve compare() metodu, char tipindeki C-stili string'lerle doğrudan karşılaştırmayı destekler. Örneğin, std::string s = "test"; if (s == "test") { ... } geçerlidir. C-stili strcmp/strncmp fonksiyonlarını kullanmak isterseniz, std::string nesnesini s.c_str() metodu ile const char'a dönüştürmeniz gerekir.
S: String'lerin belirli bir önekini (prefix) karşılaştırmak için hangi yöntem en iyisidir?
C: std::string::compare() metodunun alt string versiyonları (örneğin str1.compare(0, prefix_len, str2)) veya strncmp (strncmp(str1.c_str(), str2.c_str(), prefix_len)) bu iş için idealdir. std::string::rfind() veya std::string::starts_with() (C++20 ve sonrası) gibi metotlar da önek kontrolleri için kullanılabilir.