Sınıf ve Nesneler
Sınıf, birlikte çalışan bir dizi değişken ve işlevdir; değişkenlerin atanmış değerleri olmadığı yer. Değişkenlere değerler atandığında, sınıf bir nesne haline gelir. Aynı sınıfa verilen farklı değerler farklı nesnelerle sonuçlanır; yani, farklı nesneler, farklı değerlere sahip aynı sınıftır. Bir sınıftan bir nesne yaratmanın, nesneyi somutlaştırmak olduğu söylenir.
İsim, string, bir sınıftır. String sınıfından oluşturulan bir nesnenin programcı tarafından seçilen bir adı vardır.
Sınıftan bir nesneyi başlatmak için sınıfa ait bir fonksiyona ihtiyaç vardır. C++'da bu işlev, sınıfın adıyla aynı ada sahiptir. Sınıftan oluşturulan (örneklenen) nesneler, programcı tarafından kendilerine verilen farklı isimlere sahiptir.
Bir sınıftan nesne oluşturmak, nesneyi oluşturmak anlamına gelir; aynı zamanda somutlaştırmak demektir.
String sınıfını kullanan bir C++ programı, dosyanın en üstünde aşağıdaki satırlarla başlar:
#Dahil etmek#Dahil etmek
ad alanı std kullanarak;
İlk satır giriş/çıkış içindir. İkinci satır, programın string sınıfının tüm özelliklerini kullanmasına izin vermektir. Üçüncü satır, programın standart ad alanındaki adları kullanmasına izin verir.
Bir Fonksiyonu Aşırı Yüklemek
İki veya daha fazla farklı işlev imzası aynı ada sahip olduğunda, bu adın aşırı yüklendiği söylenir. Bir işlev çağrıldığında, argümanların sayısı ve türü, hangi işlevin yürütüleceğini belirler.
Yapı
sicim()
Aşağıdaki ifade, karakter içermeyen sıfır uzunlukta bir dize oluşturur.
Sınıfın adı (nesne türü), dize ile başlar. Bunu, programcı tarafından verilen nesne dizisinin adı izler. Atama operatörü aşağıdaki gibidir; ardından boş parantezli kurucunun adı. Burada strCol, tüm veri üyeleri (özellikler) ve üye işlevleri (yöntemler) ile somutlaştırılmış nesnedir.
dize(str)
Bu, yukarıdakine benzer, ancak yapıcıda argüman olarak bir dize değişmezi veya bir tanımlayıcı alır. Aşağıdaki ifade bunu göstermektedir:
Başlatıcı Listesi ile İnşaat
Aşağıdaki kod bunu göstermektedir:
dize strCol=sicim({'BEN','','NS','veya','v','Ve','','ve','veya','sen',' 0'});Dize harfi seni seviyorum. Başlatıcı listesinin sonundaki boş karakteri not edin.
dize(str, n)
Bu, başka bir dizenin ilk n karakterinden oluşan bir dize koleksiyonu oluşturur. Aşağıdaki kod bunu göstermektedir:
karakterP[] = 'Seni seviyorum';dize strCol=sicim(P, 6);
maliyet<<strCol<< ' ';
Çıktı, seni seviyorum'dan ilk 6 karakterle seviyorum. Unutmayın: tek boşluk bir karakterdir.
string(str, konum, n)
Bu, başka bir dizenin sıfır tabanlı dizine alınmış konumundan (pos) başlayarak n karakterlik bir dize koleksiyonu oluşturur. Aşağıdaki kod bunu göstermektedir:
karakterP[] = 'Seni seviyorum';dize strCol=sicim(P, 2, 4);
maliyet<<strCol<< ' ';
Çıktı, aşkım.
Yukarıdaki iki durum için, n, dizenin boyutundan büyükse, out_of_range istisnası atılır – daha sonra bakın.
string(n, 'c')
Tüm karakterlerin aynı olduğu n karakterlik bir koleksiyon oluşturur. Düşünmek,
dize strCol=sicim(5,'Ve');maliyet<<strCol<< ' ';
Çıktı, eeee, 5 e'dir.
Bir Dize Atama
Her iki diziyi de bildirdikten sonra, bir dizi aşağıdaki gibi atanabilir:
dize strCol1=sicim('Seni seviyorum');dize strCol2;
strCol2=strCol1;
maliyet<<strCol2<< ' ';
Çıktı, seni seviyorum.
Yineleyici ile Oluşturma
Bir yineleyici, bir koleksiyonun değerleri aracılığıyla taramanın genel bir temsilini sağlar. Yineleyici ile bir dize oluşturmak için bir sözdizimi şöyledir:
şablon<sınıf InputIterator>basic_string(InputIterator başlar,InputIterator sonu, consttahsisatçı&
ile=tahsisatçı());
Bu, [begin, end) aralığı için bir dize oluşturur - ayrıntılara daha sonra bakın.
Bir Dize Yok Etme
Bir dizeyi yok etmek için kapsam dışına çıkmasına izin verin.
Dize Sınıfı Öğe Erişimi
Örneklenmiş bir dize nesnesi, bir dizi gibi alt komut dosyası oluşturulabilir (dizine eklenebilir). Endeks sayımı sıfırdan başlar.
dizeAdı[i]
stringName[i] işlemi, i'deki karaktere (eleman) bir başvuru döndürür.NSkarakter koleksiyonunun dizini. Aşağıdaki kod çıktısı v:
dize strCol=sicim('Seni seviyorum');karakterch=strCol[4];
maliyet<<ch<< ' ';
stringName[i] const
Dize nesnesi sabit bir nesne olduğunda, dizeAdı[i] yerine dizeAdı[i] const işlemi yürütülür. Örneğin aşağıdaki kodda kullanılır:
constdize strCol=sicim('Seni seviyorum');karakterch=strCol[4];
maliyet<<ch<< ' ';
İfade, i öğesine sabit bir başvuru döndürürNSdize nesnesinin öğesi. Dizenin öğelerinin hiçbiri değiştirilemez.
Alt Simge ile Karakter Atama
Sabit olmayan bir dize nesnesine aşağıdaki gibi bir karakter atanabilir:
dize strCol=sicim('Ararım');strCol[2] = 'F';
maliyet<<strCol<< ' ';
Çıktı ben düşüyorum. 'c', 'f' olarak değiştirildi.
stringName.at(i)
stringName.at(i), stringName[i] ile benzerdir, ancak stringName.at(i) daha güvenilirdir. Aşağıdaki kod, nasıl kullanılması gerektiğini gösterir:
dize strCol=sicim('Seni seviyorum');karakterch=strCol.NS(4);
maliyet<<ch<< ' ';
at() aslında bir dize sınıfı üye işlevidir.
stringName.at(i) const
stringName.at(i) const, stringName[i] const'a benzer, ancak stringName.at(i) const daha güvenilirdir. dize nesnesi sabit bir dize nesnesi olduğunda, stringName.at(i) yerine stringName.at(i) const yürütülür. Aşağıdaki kodda kullanılır, örneğin:
constdize strCol=sicim('Seni seviyorum');karakterch=strCol.NS(4);
maliyet<<ch<< ' ';
at() const aslında bir dize sınıfı üye işlevidir.
at() Fonksiyonu ile Değer Atama
At() işleviyle sabit olmayan bir dize nesnesine aşağıdaki gibi bir değer atanabilir:
dize strCol=sicim('Ararım');strCol.NS(2) = 'F';
maliyet<<strCol<< ' ';
Çıktı ben düşüyorum.
Alt komut dosyası oluşturma ile ilgili sorun
Alt komut dosyası oluşturma (dizin oluşturma) ile ilgili sorun, dizin aralık dışındaysa, yanlış sonuç elde edilebilir veya çalışma zamanında bir hata verilebilir.
ön()
Bu, öğeyi kaldırmadan dize nesnesinin ilk öğesine bir başvuru döndürür. Aşağıdaki kodun çıktısı 'I'dir.
dize strCol=sicim('Seni seviyorum');karakterch=strCol.ön();
maliyet<<ch<< ' ';
Karakter, dize nesnesinden kaldırılmaz.
ön() const
Dize nesne yapısından önce const olduğunda, front() yerine front() const ifadesi yürütülür. Örneğin aşağıdaki kodda kullanılır.
constdize strCol=sicim('Seni seviyorum');karakterch=strCol.ön();
maliyet<<ch<< ' ';
Sabit bir başvuru döndürülür. Öğe, dize nesnesinden kaldırılmaz. Sabit bir dize nesnesi için hiçbir karakter değiştirilemez.
geri()
Bu, öğeyi kaldırmadan dize nesnesinin son öğesine bir başvuru döndürür. Aşağıdaki kodun çıktısı 'u'dur.
dize strCol=sicim('Seni seviyorum');karakterch=strCol.geri();
maliyet<<ch<< ' ';
geri() const
Dize nesne yapısından önce const geldiğinde, geri() yerine geri() const ifadesi yürütülür. Örneğin aşağıdaki kodda kullanılır.
constdize strCol=sicim('Seni seviyorum');karakterch=strCol.geri();
maliyet<<ch<< ' ';
Sabit bir başvuru döndürülür. Öğe, dize nesnesinden kaldırılmaz.
Tel Kapasitesi
size_type kapasite() const noexcept
Dizenin yeniden tahsis gerektirmeden tutabileceği toplam karakter sayısı, bu kapasite üye işlevi tarafından döndürülür. Bunun için bir kod segmenti:
dize strCol=sicim();intbirde=strCol.kapasite();
maliyet<<birde<< ' ';
Çıktı bilgisayarımda 15'tir.
yedek(n)
Bellek alanı her zaman ücretsiz mağazada bulunmaz. Ekstra alan önceden rezerve edilebilir. Aşağıdaki kod segmentini göz önünde bulundurun:
dize strCol=sicim('Aşk');strCol.rezerv(6);
maliyet<<strCol.kapasite() << ' ';
Çıktı bilgisayarımda 15'tir.
size() const noexcept
Bu, dizedeki karakter sayısını döndürür. Aşağıdaki kod gösterilmektedir:
dize strCol=sicim('Seni seviyorum');intbirde=strCol.boy();
maliyet<<birde<< ' ';
Çıktı, nul, karakterini içermeyen 10'dur.
uzunluk() const noexcept
-boyutla aynı().Not:boy() <=kapasite().
sığdırmak için küçültmek()
Yeniden tahsise neden olarak kapasiteyi () size () azaltabilir; zorunlu değildir. Aşağıdaki kod bunu gösterir:
dize strCol=sicim('Seni seviyorum');strCol.rezerv(12);
strCol.sığdırmak için küçültmek();
ints=strCol.boy();
maliyet<<s<< ' ';
Çıktı 10'dur ve 12 veya 16 değildir. İşlev void döndürür.
yeniden boyutlandır(sz), yeniden boyutlandır(sz,'c')
Bu, dizeyi yeniden boyutlandırır. Yeni boyut eski boyuttan küçükse, sona doğru olan öğeler silinir. Yeni boyut daha uzunsa, sonuna doğru bazı varsayılan karakterler eklenir. Belirli bir karakterin eklenmesi için resize() işlevini iki bağımsız değişkenle kullanın. Aşağıdaki kod parçası, iki işlevin kullanımını gösterir:
dize strCol=sicim('Seni seviyorum');strCol.yeniden boyutlandırmak(6);
maliyet<< 'StrCol'ün yeni boyutu:' <<strCol.boy() << ' ';
dize strCol1=sicim('Seviyorum', 'Ve');
strCol1.yeniden boyutlandırmak(12);
maliyet<< 'StrCol1'in yeni boyutu:' <<strCol1.boy() << ' ';
Çıktı:
Yeni strCol boyutu: 6strCol1'in yeni boyutu: 12
İşlev void döndürür.
clear() istisnasız
Aşağıdaki kod segmentinde gösterildiği gibi, tüm öğeleri dizeden kaldırır:
dize strCol=sicim('Seni seviyorum');strCol.açık();
maliyet<<strCol.boy() << ' ';
Çıktı 0'dır. İşlev void döndürür.
boş() const noexcept
Bu, dize nesnesinde karakter yoksa true için 1 veya dize nesnesi boş değilse false için 0 döndürür. Aşağıdaki kod bunu göstermektedir:
dize strCol1=sicim('Seni seviyorum');maliyet<<strCol1.boş() << ' ';
dize strCol2=sicim();
maliyet<<strCol2.boş() << ' ';
Çıktı:
01
Yineleyiciler ve String Sınıfının Döndürülmesi
Yineleyici bir işaretçi gibidir ancak işaretçiden daha fazla işlevselliğe sahiptir.
start() noexcept
Aşağıdaki kod segmentinde olduğu gibi, dize nesnesinin ilk karakterine (öğesine) işaret eden bir yineleyici döndürür:
dize strCol=sicim('Seni seviyorum');basic_string<karakter> ::yineleyiciyineleme=strCol.başlamak();
maliyet<< *yineleme<< ' ';
Çıktı 'ben'dir. Yineleyiciyi alan bildirimin nasıl bildirildiğine dikkat edin. Değeri elde etmek için bir dönüş ifadesinde yineleyicinin başvurusu kaldırılır, tıpkı bir işaretçinin başvurusunun kaldırıldığı gibi.
start() const noexcept;
Dize nesne koleksiyonunun ilk öğesine işaret eden bir yineleyici döndürür. Nesne yapısından önce const geldiğinde, start() yerine startup() const ifadesi yürütülür. Bu koşul altında, nesnedeki karşılık gelen öğe değiştirilemez. Örneğin aşağıdaki kodda kullanılır.
constdize strCol=sicim('Seni seviyorum');basic_string<karakter> ::const_iteratoryineleme=strCol.başlamak();
maliyet<< *yineleme<< ' ';
Çıktı 'ben'dir. Döndürülen yineleyiciyi almak için bu sefer yalnızca yineleyici yerine const_iterator kullanıldığını unutmayın.
end() noexcept
Dize nesnesinin son öğesinin hemen ötesine işaret eden bir yineleyici döndürür. Aşağıdaki kod segmentini göz önünde bulundurun:
dize strCol=sicim('Seni seviyorum');basic_string<karakter> ::yineleyiciyineleme=strCol.son();
maliyet<< *yineleme<< ' ';
Son öğenin ötesinde somut bir öğe olmadığı için çıktı boştur, bu hiçbir şey değildir.
end() const noexcept
Dize nesnesinin son öğesinin hemen ötesine işaret eden bir yineleyici döndürür. Dize nesne yapısından önce const geldiğinde, end() yerine end() const ifadesi yürütülür. Aşağıdaki kod segmentini göz önünde bulundurun:
constdize strCol=sicim('Seni seviyorum');basic_string<karakter> ::const_iteratoryineleme=strCol.son();
maliyet<< *yineleme<< ' ';
Çıktı boş. Döndürülen yineleyiciyi almak için bu sefer yalnızca yineleyici yerine const_iterator kullanıldığını unutmayın.
Ters yineleme
Gerçek sondan ilk öğenin hemen öncesine kadar yinelenen bir yineleyiciye sahip olmak mümkündür:
rbegin() noexcept
Aşağıdaki kod segmentinde olduğu gibi, dize somutlaştırılan nesnenin son öğesine işaret eden bir yineleyici döndürür:
dize strCol=sicim('Seni seviyorum');basic_string<karakter> ::ters_iteratöryineleme=strCol.yeniden başlamak();
maliyet<< *yineleme<< ' ';
Çıktı 'u'. Ters yineleyiciyi alan bildirimin bildirilme biçimine dikkat edin. Değeri elde etmek için bir dönüş ifadesinde yineleyicinin başvurusu kaldırılır, tıpkı bir işaretçinin başvurusunun kaldırıldığı gibi.
rbegin() const noexcept;
Dize nesnesinin son öğesine işaret eden bir yineleyici döndürür. Nesne yapısından önce const geldiğinde, rbegin() yerine rbegin() const ifadesi yürütülür. Bu koşul altında, nesnedeki karşılık gelen öğe değiştirilemez. Özellik, örneğin aşağıdaki kodda kullanılır.
constdize strCol=sicim('Seni seviyorum');basic_string<karakter> ::const_reverse_iteratoryineleme=strCol.yeniden başlamak();
maliyet<< *yineleme<< ' ';
Çıktı 'u'. Döndürülen yineleyiciyi almak için bu sefer sadece reverse_iterator yerine const_reverse_iterator kullanıldığını unutmayın.
render () hariç
Dize nesnesinin ilk öğesinin hemen öncesine işaret eden bir yineleyici döndürür. Aşağıdaki kod segmentini göz önünde bulundurun:
dize strCol=sicim('Seni seviyorum');basic_string<karakter> ::ters_iteratöryineleme=strCol.yapar();
maliyet<< *yineleme<< ' ';
İlk öğeden hemen önce somut bir öğe olmadığı için çıktı boştur, bu hiçbir şey değildir.
render () const noexcept
Dize nesnesinin ilk öğesinin hemen öncesine işaret eden bir yineleyici döndürür. Nesne yapısından önce const olduğunda, rend() yerine rend() const ifadesi yürütülür. Aşağıdaki kod segmentini göz önünde bulundurun:
constdize strCol=sicim('Seni seviyorum');basic_string<karakter> ::const_reverse_iteratoryineleme=strCol.yapar();
maliyet<< *yineleme<< ' ';
Çıktı boş. Döndürülen yineleyiciyi almak için bu sefer sadece reverse_iterator yerine const_reverse_iterator kullanıldığını unutmayın.
Dize Değiştiriciler
Dize nesnesini değiştiren bir değiştirici, bir yineleyici de alabilir veya döndürebilir.
ekleme
basic_string&Şebeke+ =(constbasic_string&P)Sağ dize nesnesini sol dize nesnesine ekler. Örnek:
dize strCol1=sicim('Seviyorum');dize strCol2=sicim(' sen');
strCol1+ =strCol2;
maliyet<<strCol1<< ' ';
Çıktı seni seviyorum. strCol1 += strCol2'nin strCol1 = strCol1+strCol2 ile aynı olduğunu unutmayın.
basic_string& operatör+=(const charT* s)
Bir dize nesne koleksiyonuna bir dize değişmez değeri ekler. Örnek:
dize strCol=sicim('Seviyorum');strCol+ = ' sen';
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum.
basic_string& operatör+=(charT c)
Bir nesne dizesine tek bir karakter ekler. Örnek:
dize strCol=sicim('Seni seviyorum');strCol+ = 'sen';
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum.
basic_string& operatör+=(initializer_list)
Bir başlatıcı listesi ekler. Örnek:
dize strCol=sicim('Seviyorum');strCol+ = {'','ve','veya','sen',' 0'};
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum. Karakter başlatıcı listesinin sonuna nul, eklemek her zaman iyidir.
basic_string& ekleme(const basic_string& str)
Argüman dizesi nesnesini ana dize nesnesine ekler. Örnek:
dize strCol1=sicim('Seviyorum');dize strCol2=sicim(' sen');
strCol1.eklemek(strCol2);
maliyet<<strCol1<< ' ';
Çıktı: Seni seviyorum.
basic_string& append(const charT* s)
Ana dizeye bir dize değişmez bağımsız değişkeni ekler. Örnek
dize strCol=sicim('Seviyorum');strCol=strCol.eklemek(' sen');
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum.
basic_string& append(initializer_list)
Bir argüman olan başlatıcı listesini ana dizeye ekler. Örnek:
dize strCol=sicim('Seviyorum');strCol=strCol.eklemek({'','ve','veya','sen',' 0'});
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum. Başlatıcı listesinin sonuna nul, karakterini eklemek her zaman iyidir.
basic_string& append(size_type n, charT c)
Aynı karakterin n'sini ekler. Örnek:
dize strCol=sicim('sekme');strCol=strCol.eklemek(2, 'veya');
maliyet<<strCol<< ' ';
Çıktı: tabu.
basic_string& append(const charT* s, size_type n)
Bir dize değişmezinin ilk n öğesini ana dize nesnesine ekler. Örnek:
dize strCol=sicim('Seviyorum');strCol=strCol.eklemek('sen öyle', 4);
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum. n, değişmezin uzunluğundan büyükse, bir uzunluk_hatası istisnası atılır.
basic_string& append(const basic_string& str, size_type konum, size_type n = npos)
Dizinden n karakter ekler, ana dizgeye konumlandırır. Örnek:
dize strCol=sicim('Seviyorum');strCol=strCol.eklemek('sen öyle', 2, 4);
maliyet<<strCol<< ' ';
Çıktı: Seni seviyorum. Burada da bir istisna atılır, daha sonra bakın.
atama
basic_string&atamak(constbasic_string&P)Argüman dizesi nesnesini, orada bulunan herhangi bir içeriği değiştirerek ana dizeye atar.
dize strCol1=sicim('Seni seviyorum');dize strCol2=sicim('Onun bana ihtiyacı var');
strCol1=strCol1.atamak(strCol2);
maliyet<<strCol1<< ' ';
Çıktı: Bana ihtiyacı var.
basic_string&atamak(constÇizelge*s)Ana dizeye, orada bulunan herhangi bir içeriği değiştirerek bir dize değişmez argümanı atar.
dize strCol=sicim('Seni seviyorum');strCol=strCol.atamak('Onun bana ihtiyacı var');
maliyet<<strCol<< ' ';
Çıktı: Bana ihtiyacı var.
basic_string&atamak(başlatıcı_listesi<Çizelge>)Ana dizeye bir başlatıcı listesi argümanı atar,orada bulunan herhangi bir içeriği değiştirmek.
[cc dili='C'kaçtı='NS'Genişlik='780']
dize strCol=sicim('Seni seviyorum');
strCol=strCol.atamak({'S','H','Ve','','n','Ve','Ve','NS','s','','m','Ve',' 0'});
maliyet<<strCol<< ' ';
Çıktı: Bana ihtiyacı var. Bir dize değişmezi oluşturmak için her zaman karakter listesinin sonuna nul eklemek iyidir.
basic_string&atamak(constÇizelge*s,size_type n)Bir dize değişmez bağımsız değişkeninin ilk n karakterini, orada bulunan herhangi bir içeriği değiştirerek ana dizeye atar.
dize strCol=sicim('Seni seviyorum');strCol=strCol.atamak('Onun bana ihtiyacı var', 9);
maliyet<<strCol<< ' ';
Çıktı: İhtiyacı var.
basic_string&atamak(size_type n,grafik)Ana dizeye, orada bulunan herhangi bir içeriği değiştirerek, aynı karakterlerden n'lik bir argüman atar.
dize strCol=sicim('Seni seviyorum');strCol=strCol.atamak(4, 'Ve');
maliyet<<strCol<< ' ';
çıktı: eeee
basic_string&atamak(constbasic_string&P,size_type konum,size_type n=npos)
Bir dize nesne bağımsız değişkeninin n karakterini, orada bulunan herhangi bir içeriği değiştirerek ana dizeye pos'dan başlayarak atar.
dize strCol=sicim('Seni seviyorum');strCol=strCol.atamak('Onun bana ihtiyacı var', 4, 5);
maliyet<<strCol<< ' ';
Çıktı: ihtiyaçlar. Bir istisna atardım - sonra bakın.
ekleme
basic_string&sokmak(size_type konum, constbasic_string&P)Dizin nesnesi bağımsız değişkenini ana dizeye, dizinde, konum olarak ekler.
dize strCol1=sicim('Seni seviyorum');dize strCol2=sicim('nefret ve');
strCol1=strCol1.sokmak(2,strCol2);
maliyet<<strCol1<< ' ';
Çıktı: Senden nefret ediyorum ve seviyorum. Bir istisna atardım - sonra bakın.
basic_string&sokmak(size_type konum1, constbasic_string&P,size_type konum2,size_type n=npos)
Dizin nesne bağımsız değişkeninin konum2'sinden konum1 dizinindeki ana dizeye n karakter uzunluğunda ekler.
dize strCol1=sicim('Seni seviyorum');dize strCol2=sicim('nefret, istek ve ihtiyaç');
strCol1=strCol1.sokmak(2,strCol2, 6, 9);
maliyet<<strCol1<< ' ';
Çıktı: Seni istiyorum ve seviyorum.
yineleyici ekleme(const_iterator p, charT c)
Yineleyici tarafından işaret edilen konuma bir argüman olan belirli bir karakteri ekler. Yeni eklenen karakterin konumu için bir yineleyici döndürür.
dize strCol=sicim('Seni seviyorum');basic_string<karakter> ::yineleyiciyineleme=strCol.başlamak();
++yineleme; ++yineleme; ++yineleme; ++yineleme; ++yineleme; ++yineleme;
basic_string<karakter> ::yineleyiciağ=strCol.sokmak(yineleme, 'NS');
maliyet<< *ağ<< ' ';
maliyet<<strCol<< ' ';
Çıktı:
'NS'
seni sevdim
yineleyici ekleme(const_iterator p, size_type n, charT c)
Yineleyici tarafından gösterilen konuma, argümanın aynı karakterinden n ekler. Yeni eklenen aynı karakterlerin başlangıcının konumu için bir yineleyici döndürür.
dize strCol=sicim('Topraktaki sekme.');basic_string<karakter> ::yineleyiciyineleme=strCol.başlamak();
++yineleme; ++yineleme; ++yineleme;
basic_string<karakter> ::yineleyiciağ=strCol.sokmak(yineleme, 2, 'veya');
maliyet<< *ağ<< ' ';
maliyet<<strCol<< ' ';
Çıktı:
'veya'
Ülkede tabu.
basic_string&sokmak(size_type konum, constÇizelge*s)Dizine bir argüman dizesi değişmez değeri ekler, ana dizgede pos.
dize strCol=sicim('Topraktaki sekme.');strCol=strCol.sokmak(3, 'oo');
maliyet<<strCol<< ' ';
Çıktı: Ülkede tabu.
basic_string&sokmak(size_type konum, constÇizelge*s,size_type n)Argüman dizesi değişmezinin ilk n karakterini dizine, ana dizedeki konumuna ekler.
dize strCol=sicim('Topraktaki sekme.');strCol=strCol.sokmak(3, 'oooo', 2);
maliyet<<strCol<< ' ';
Çıktı: Ülkede tabu.
değiştirme
basic_string&yer değiştirmek(size_type konum1,size_type n1, constbasic_string&P))Ana dize nesnesindeki n1 karakterlerini dizin, konum1'den bağımsız değişken dizesi nesnesiyle değiştirir.
dize strCol1=sicim('Seni seviyorum');dize strCol2=sicim('senden nefret ediyorum ve');
strCol1=strCol1.yer değiştirmek(2, 4,strCol2);
maliyet<<strCol1<< ' ';
Çıktı: Senden ve senden nefret ediyorum. Bir istisna atardım - sonra bakın.
basic_string&yer değiştirmek(size_type konum1,size_type n1, constbasic_string&P,size_type konum2,size_type n2=npos)
pos1 dizinindeki ana dize nesnesindeki n1 karakterlerini, konum2 dizinindeki argüman dizesi nesnesinin n2 karakterleriyle değiştirir.
dize strCol1=sicim('Seni seviyorum');dize strCol2=sicim('Ondan ve ondan nefret ediyoruz');
strCol1=strCol1.yer değiştirmek(2, 4,strCol2, 3, 12);
maliyet<<strCol1<< ' ';
Çıktı: Ondan ve senden nefret ediyorum.
basic_string&yer değiştirmek(size_type konum1,size_type n1, constÇizelge*s,size_type n2)
pos1 dizinindeki ana dize nesnesindeki n1 karakterlerini, değişmez dize bağımsız değişkeninin ilk n2 karakteriyle değiştirir.
dize strCol1=sicim('Seni seviyorum');strCol1=strCol1.yer değiştirmek(2, 4, 'Ondan ve ondan nefret ediyorum', 12);
maliyet<<strCol1<< ' ';
Çıktı: Ondan ve senden nefret ediyorum.
basic_string& replace(size_type pos, size_type n, const charT* s)
Ana dize nesnesindeki n karakterini dizin, pos, değişmez dize bağımsız değişkeniyle değiştirir.
dize strCol1=sicim('Seni seviyorum');strCol1=strCol1.yer değiştirmek(2, 4, 'Ondan nefret ediyorum ve');
maliyet<<strCol1<< ' ';
Çıktı: Ondan ve senden nefret ediyorum.
basic_string&yer değiştirmek(size_type konum1,size_type n1,size_type n2,grafik)pos1 dizinindeki ana dize nesnesindeki n1 karakterlerini, argümanın aynı karakterinin n2'si ile değiştirir.
dize strCol1=sicim('Orada kötü bir tablet.');strCol1=strCol1.yer değiştirmek(9, 3, 2, 'veya');
maliyet<<strCol1<< ' ';
Çıktı: Orada kötü bir tabu..
yineleyici silme(const_iterator p)
Yineleyici tarafından işaret edilen konumdaki bir karakteri kaldırır; sonra bu karakterin (veya end()) yanında bulunan karakter tarafından işgal edilen yineleyici konumunu döndürür. Aşağıdaki kod bunu göstermektedir:
dize strCol=sicim('abcd');basic_string<karakter> ::yineleyiciyineleme=strCol.başlamak();
++yineleme; ++yineleme;
strCol.silmek(yineleme);
maliyet<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' ';
çıktı: a b d
basic_string&silmek(size_type konum= 0,size_type n=npos)Dizinden n karakteri kaldırır, konum.
dize strCol=sicim('abcd');strCol.silmek(1, 2);
maliyet<<strCol[0] << '' <<strCol[1] << ' ';
Çıktı: bir d
geçersiz push_back(charT c)
Dizenin sonuna tek bir karakter eklemek için:
dize strCol=sicim('abcd');strCol.Geri itmek('5');
maliyet<<strCol<< ' ';
Çıktı: abcd5
geçersiz pop_back()
Son karakteri döndürmeden kaldırır. Dizenin boyutu 1 azaltılır.
dize strCol=sicim('abcde');strCol.pop_back();
maliyet<<strCol<< ' ';
Çıktı: abcd
geçersiz takas(basic_string& s)
İki dize nesnesinin değişmez değerleri değiştirilebilir.
dize strCol1=sicim(<yardım='post-69618-__DdeLink__781_3724385525'>ile>'abcde');dize strCol2=sicim('1234567');
strCol1.takas(strCol2);
maliyet<<strCol1<< ' ';
maliyet<<strCol2<< ' ';
Çıktı:
'1234567''abcde'
Dizi İşlemleri
const charT* c_str() const noexcept
Dizenin ilk öğesine bir işaretçi döndürür. İşaretçi artırılabilir.
constdize strCol=sicim('abcde');const karakter*P=strCol.c_str();
maliyet<< *P<< ' ';
++P;
maliyet<< *P<< ' ';
Çıktı:
ileB
Başlıktaki ikinci const nedeniyle, program dizedeki herhangi bir karakteri değiştiremez. İnşaattan önce const.
const charT* data() const noexcept
Dizenin ilk öğesine bir işaretçi döndürür. İşaretçi artırılabilir.
constdize strCol=sicim('abcde');const karakter*P=strCol.veri();
maliyet<< *P<< ' ';
++P;
maliyet<< *P<< ' ';
Çıktı:
ileB
Başlıktaki ikinci const nedeniyle, program dizedeki herhangi bir karakteri değiştiremez. İnşaattan önce const.
basic_string substr(size_type konum = 0, size_type n = npos) const
Dizinden başlayarak alt dize için n karakterlik bir dize nesnesi döndürür, konum.
constdize strCol=sicim('abcdefghij');constdize retStr=strCol.alt dizi(2, 4);
maliyet<<retStr<< ' ';
Çıktı: cdef
find() Üye İşlevleri
size_type find(const basic_string& str, size_type pos = 0) const noexcept
Dizinden başlayarak bir alt dize nesnesi arar, pos. Bulunursa, ana dizedeki alt dizenin başlangıcını döndürür.
dize strCol=sicim('Biz dünyayız!');dize strCol1=sicim('NS');
intbirde=strCol.bulmak(strCol1, 2);
maliyet<<birde<< ' ';
Çıktı:
dizin: 7Bulunamadığında -1 döndürür.
size_type find(const charT* s, size_type konum = 0) const
Dizinden başlayarak bir alt dize değişmezi arar, pos. Bulunursa, ana dizedeki alt dizenin başlangıcını döndürür.
dize strCol=sicim('Biz dünyayız!');intbirde=strCol.bulmak('NS', 0);
maliyet<<birde<< ' ';
pos = 0 varsayılan olduğundan, bağımsız değişkende 0 atlanmış olabilir.
Çıkış: 3
Bulunamadığında -1 döndürür.
size_type find (const charT* s, size_type konumu, size_type n) const
Dizinden başlayarak bir alt dize değişmezinin ilk n karakterini arar, konum. Bulunursa, ana dizedeki alt dizenin başlangıcını döndürür.
dize strCol=sicim('En büyük çocuk');intbirde=strCol.bulmak('daha büyük', 1, 3);
maliyet<<birde<< ' ';
Çıkış: 4
Bulunamadığında -1 döndürür.
size_type find(charT c, size_type konum = 0) const
Dizinden başlayarak c karakterini arar, pos. Bulunursa, ana dizedeki alt dizenin başlangıcını döndürür. Bulunamazsa, -1 döndürür.
dize strCol=sicim('Biz dünyayız!');intbirde=strCol.bulmak('İle birlikte');
maliyet<<birde<< ' ';
Çıktı: -1
Aşağıdaki ters find() üye işlevleri mevcuttur:
size_type rfind(constbasic_string&P,size_type konum=npos) constistisnasız;size_type rfind(constÇizelge*s,size_type konum=npos) const;
size_type rfind(constÇizelge*s,size_type konum,size_type n) const;
size_type rfind(grafik,size_type konum=npos) const;
Karşılaştırma Üyesi İşlevleri
int karşılaştırma(const basic_string& str) const noexcept
Argüman dizesi nesnesini ana dize nesnesiyle karşılaştırır. Ana dize argümandan önce gelirse (sözlükte) pozitif bir sayı döndürür. Ana dizeden sonra gelirse, negatif bir sayı döndürür. İki dize aynıysa, sıfır döndürür.
dize strCol1=sicim('kalabalık');dize strCol2=sicim('insanlar');
intbirde=strCol1.karşılaştırmak(strCol2);
maliyet<<birde<< ' ';
Çıkış: -13
int karşılaştırma(const charT* s) const
Yukarıdakiyle aynı, ancak argüman bir dize değişmezidir.
dize strCol1=sicim('insanlar');intbirde=strCol1.karşılaştırmak('insanlar');
maliyet<<birde<< ' ';
Çıkış: 0
String Operatörleri
Bu işleçler, dize nesnelerine uygulanabilir ve dize değişmezleri olması gerekmez.
+
İki dize nesnesini birleştirir ve birleştirmeyi döndürür.
dize strCol1=sicim('dans etmek');dize strCol2=sicim(' ay');
dize strCol=strCol1+strCol2;
maliyet<<strCol<< ' ';
Çıktı: ayda dans etmek.
==
Dize nesneleri aynıysa true için 1 döndürür; ve değilse, false için sıfır.
dize strCol1=sicim('dans etmek');dize strCol2=sicim(' Ay'da');
bool bl=strCol1==strCol2;
maliyet<<bl<< ' ';
Çıkış: 0
! =
Dize nesneleri aynı değilse 1, aynıysa sıfır döndürür.
dize strCol1=sicim('dans etmek');dize strCol2=sicim(' Ay'da');
bool bl=strCol1! =strCol2;
maliyet<<bl<< ' ';
Çıktı: 1
<
Sol işlenen sözlüğe göre sağ işlenenden küçükse 1, değilse sıfır döndürür.
dize strCol1=sicim('dans etmek');dize strCol2=sicim(' Ay'da');
bool bl=strCol1<strCol2;
maliyet<<bl<< ' ';
Çıkış: 0
C++'daki sıradan karakterler için, artan sırada sayılar küçük harflerden önce gelen büyük harflerden önce gelir. Boşluk karakteri sıfırdan ve hepsinden önce gelir.
C++ Ana Dize Karakter Türleri
karakter
Char tipi orijinal C++ tipidir ve tipik olarak 8 bitlik bir karakter saklar.
karakter16_t
Bu, bir karakteri 16 bitte saklar.
char32_t
Bu, bir karakteri 32 bit olarak saklar.
wchar_t
char16_t ve char32_t geniş karakterlerdir. wchar_t, tescilli ve uygulama tanımlı geniş bir karakterdir.
Bu türlere nitelik denir. Bununla birlikte, C++ teknik olarak onları özelliklerin uzmanlıkları olarak ifade eder. Bu makale char türüne odaklanmıştır. Diğer türlere yaklaşım biraz farklıdır – daha sonra bakınız.
Diğer Dize İşlem Üye İşlevleri
Diğer dize işlem işlevlerinin imzaları şunlardır:
size_type find_first_of(constbasic_string&P,size_type konum= 0) constistisnasız;size_type find_first_of(constÇizelge*s,size_type konum,size_type n) const;
size_type find_first_of(constÇizelge*s,size_type konum= 0) const;
size_type find_first_of(grafik,size_type konum= 0) const;
size_type find_last_of(constbasic_string&P,size_type konum=npos) constistisnasız;
size_type find_last_of(constÇizelge*s,size_type konum,size_type n) const;
size_type find_last_of(constÇizelge*s,size_type konum=npos) const;
size_type find_last_of(grafik,size_type konum=npos) const;
size_type find_first_not_of(constbasic_string&P,size_type konum= 0) constistisnasız;
size_type find_first_not_of(constÇizelge*s,size_type konum,size_type n) const;
size_type find_first_not_of(constÇizelge*s,size_type konum= 0) const;
size_type find_first_not_of(grafik,size_type konum= 0) const;
size_type find_last_not_of(constbasic_string&P,size_type konum=npos) constistisnasız;
size_type find_last_not_of(constÇizelge*s,size_type konum,size_type n) const;
size_type find_last_not_of(constÇizelge*s,size_type konum=npos) const;
size_type find_last_not_of(grafik,size_type konum=npos) const;
Çözüm
C++, dize değişmezlerine ve dize nesnelerine sahiptir. String nesnesi, sırayla bir dizi karakter dizisine benzer şekilde, sırayla bir karakter koleksiyonuna sahiptir. Dize koleksiyonu ile dizi arasındaki fark, dize koleksiyonunun uzunluk olarak büyüyebilmesi veya küçülebilmesidir. Bir dize nesnesi, bir dize sınıfından başlatılır (inşa edilir). Bir dize nesnesi, üye işlevlere sahip bir veri yapısıdır. Üye işlevler, nesne oluşturma, eleman erişimi, dizgi kapasitesi, yineleyici argümanları ve dönüş türleri ile dizge üye işlevleri ve dizgi değiştiricileri başlıkları altında sınıflandırılabilir. Dize eşitliği ve ilişkisel operatörler de mevcuttur.