C ++ سٹرنگ کلاس کا استعمال کیسے کریں۔

How Use C String Class



سٹرنگ لیٹرل ایک مستقل صف پوائنٹر میں حروف کی ایک ترتیب ہے جو نول کردار ، 0 کے ذریعہ ختم ہوتا ہے۔ جب ایک متغیر کے ذریعہ شناخت کیا جاتا ہے تو ، سٹرنگ لٹریل واقعی لمبائی کو کم یا بڑھا نہیں سکتا۔ سٹرنگ لٹریل پر کئی آپریشن نہیں کیے جا سکتے۔ لہذا ، ایک سٹرنگ کلاس کی ضرورت ہے۔ C ++ سٹرنگ کلاس ڈیٹا سٹرکچر کے لیے ہے ، حروف کا مجموعہ ترتیب میں ، جو ممبر افعال اور آپریٹرز کو کرداروں پر عمل کرنے کی اجازت دیتا ہے۔ سٹرنگ کلاس متعلقہ سٹرنگ لٹریل پر زیادہ ہیرا پھیری کی اجازت دیتی ہے ، صرف سٹرنگ لٹریل کے بجائے۔ اس مضمون کو سمجھنے کے لیے آپ کو لفظی سٹرنگ کا اچھا علم ہونا چاہیے۔

کلاس اور آبجیکٹ۔

ایک کلاس متغیرات اور افعال کا ایک مجموعہ ہے جو مل کر کام کرتے ہیں۔ جہاں متغیرات کے لیے مقرر کردہ اقدار نہیں ہیں۔ جب اقدار متغیر کو تفویض کی جاتی ہیں ، کلاس ایک شے بن جاتی ہے۔ ایک ہی طبقے کو دی گئی مختلف اقدار کا نتیجہ مختلف اشیاء پر ہوتا ہے۔ یعنی ، مختلف اشیاء مختلف اقدار کے ساتھ ایک ہی کلاس ہیں۔ کہا جاتا ہے کہ کلاس سے کوئی شے بنانا اس چیز کو فوری طور پر شروع کرنا ہے۔







نام ، سٹرنگ ، ایک کلاس ہے۔ سٹرنگ کلاس سے بنائی گئی شے میں ایک پروگرامر کا منتخب کردہ نام ہوتا ہے۔



کلاس سے تعلق رکھنے والے فنکشن کی ضرورت ہوتی ہے تاکہ کلاس سے کسی چیز کو فوری طور پر شروع کیا جا سکے۔ C ++ میں ، اس فنکشن کا وہی نام ہے جو کلاس کا نام ہے۔ کلاس سے بنائی گئی چیزیں (فوری طور پر) پروگرامر کے ذریعہ ان کو مختلف نام دیئے گئے ہیں۔



ایک کلاس سے ایک شے کی تخلیق کا مطلب آبجیکٹ کی تعمیر ہے۔ اس کا مطلب یہ بھی ہے کہ فوری طور پر





ایک C ++ پروگرام جو سٹرنگ کلاس استعمال کرتا ہے ، فائل کے اوپری حصے میں درج ذیل لائنوں سے شروع ہوتا ہے۔

#شامل کریں
#شامل کریں
نام کی جگہ کا استعمال کرتے ہوئے std؛

پہلی لائن ان پٹ/آؤٹ پٹ کے لیے ہے۔ دوسری لائن پروگرام کو سٹرنگ کلاس کی تمام خصوصیات استعمال کرنے کی اجازت دینا ہے۔ تیسری لائن پروگرام کو معیاری نام کی جگہ پر نام استعمال کرنے کی اجازت دیتی ہے۔



ایک فنکشن کو اوورلوڈ کرنا۔

جب دو یا زیادہ مختلف فنکشن دستخطوں کا ایک ہی نام ہوتا ہے ، تو کہا جاتا ہے کہ یہ نام اوورلوڈ ہے۔ جب ایک فنکشن کہا جاتا ہے تو ، دلائل کی تعداد اور قسم ، اس بات کا تعین کریں کہ کون سا فنکشن انجام دیا گیا ہے۔

تعمیراتی

تار ()
مندرجہ ذیل بیان صفر لمبائی کی ایک تار بناتا ہے جس میں کوئی حرف نہیں ہوتا ہے۔

سٹرنگ strCol=تار()؛

یہ کلاس (آبجیکٹ کی قسم) ، سٹرنگ کے نام سے شروع ہوتا ہے۔ اس کے بعد آبجیکٹ سٹرنگ کا نام آتا ہے ، جو پروگرامر نے دیا ہے۔ اسائنمنٹ آپریٹر مندرجہ ذیل ہے پھر خالی قوسین کے ساتھ کنسٹرکٹر کا نام۔ یہاں ، strCol تمام ڈیٹا ممبرز (پراپرٹیز) اور ممبر افعال (طریقوں) کے ساتھ فوری چیز ہے۔
تار (str)
یہ مذکورہ بالا کی طرح ہے ، لیکن کنسٹرکٹر میں یا تو سٹرنگ لیٹرل یا شناخت کنندہ کو بطور دلیل لیتا ہے۔ مندرجہ ذیل بیان اس کی وضاحت کرتا ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛

ابتدائی فہرست کے ساتھ تعمیر۔

مندرجہ ذیل کوڈ اس کی وضاحت کرتا ہے:

سٹرنگ strCol=تار({'میں'،''،''،'یا'،'وی'،'اور'،''،'اور'،'یا'،'تم'،''})؛

سٹرنگ لفظی ہے میں تم سے محبت کرتا ہوں. ابتدائی فہرست کے آخر میں نول کردار کو نوٹ کریں۔

سٹرنگ (str ، n)

یہ ایک سٹرنگ کلیکشن بناتا ہے ، دوسرے سٹرنگ کے پہلے ن حروف کا۔ مندرجہ ذیل کوڈ اس کی وضاحت کرتا ہے:

چارp[] = 'میں تم سے پیار کرتا ہوں'؛
سٹرنگ strCol=تار(p، )؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ یہ ہے کہ میں آپ سے پہلے 6 حروف سے محبت کرتا ہوں۔ یاد رکھیں: واحد جگہ ایک کردار ہے۔

سٹرنگ (str ، pos ، n)

یہ n حروف کا ایک سٹرنگ مجموعہ بناتا ہے ، جو صفر پر مبنی انڈیکس شدہ پوزیشن سے شروع ہوتا ہے ، ایک اور سٹرنگ کا پوز۔ مندرجہ ذیل کوڈ اس کی وضاحت کرتا ہے:

چارp[] = 'میں تم سے پیار کرتا ہوں'؛
سٹرنگ strCol=تار(p، ، )؛
لاگت<<strCol<< 'n'؛

پیداوار ہے ، محبت۔

مذکورہ بالا دو صورتوں کے لیے ، اگر n سٹرنگ کے سائز سے زیادہ ہے ، out_of_range استثناء پھینک دیا گیا ہے - بعد میں دیکھیں۔

سٹرنگ (n ، 'c')

n حروف کا مجموعہ بناتا ہے ، جہاں تمام حروف ایک جیسے ہوتے ہیں۔ غور کریں ،

سٹرنگ strCol=تار(،'اور')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ ، eeeee ، 5 e's ہے۔

سٹرنگ تفویض کرنا

دونوں ڈورز کو ڈیکلیئر کرنے کے بعد ایک سٹرنگ مندرجہ ذیل طور پر تفویض کی جا سکتی ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
سٹرنگ strCol2؛
strCol2=strCol1؛
لاگت<<strCol2<< 'n'؛

پیداوار ہے ، میں تم سے پیار کرتا ہوں۔

Iterator کے ساتھ تعمیر

ایک تکرار کنیکشن کی اقدار کے ذریعے اسکیننگ کی عمومی نمائندگی فراہم کرتا ہے۔ تکرار کے ساتھ ایک تار بنانے کے لیے ایک نحو ، ہے:

سانچے<کلاس InputIterator>
بنیادی_ سٹرنگ(InputIterator شروع،InputIterator کا اختتام۔، constمختص کرنے والا۔&
کو=مختص کرنے والا۔())؛

یہ رینج [شروع ، اختتام] کے لیے ایک تار بناتا ہے - تفصیلات بعد میں دیکھیں۔

سٹرنگ کو تباہ کرنا۔

کسی تار کو تباہ کرنے کے لیے ، اسے دائرہ کار سے باہر جانے دیں۔

سٹرنگ کلاس عنصر تک رسائی۔

ایک فوری سٹرنگ آبجیکٹ ایک سرنی کی طرح سب سکرپٹڈ (انڈیکسڈ) ہوسکتی ہے۔ انڈیکس کی گنتی صفر سے شروع ہوتی ہے۔

stringName [i]

آپریشن stringName [i] i میں کردار (عنصر) کا حوالہ لوٹاتا ہے۔ویںکریکٹر کلیکشن کا انڈیکس مندرجہ ذیل کوڈ آؤٹ پٹ v:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strCol[]؛
لاگت<<چودھری<< 'n'؛

stringName [i] const

آپریشن stringName [i] const اسٹرنگ نام [i] کی بجائے عمل میں لایا جاتا ہے جب سٹرنگ آبجیکٹ ایک مستقل چیز ہوتی ہے۔ یہ مندرجہ ذیل کوڈ میں استعمال ہوتا ہے مثال کے طور پر:

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strCol[]؛
لاگت<<چودھری<< 'n'؛

اظہار i کا مستقل حوالہ لوٹاتا ہے۔ویںسٹرنگ آبجیکٹ کا عنصر۔ تار کے عناصر میں سے کوئی بھی تبدیل نہیں کیا جا سکتا۔

سبسکرپٹ کے ساتھ ایک کریکٹر تفویض کرنا۔

ایک کردار کو غیر مستقل تار والی چیز پر تفویض کیا جاسکتا ہے ، جیسا کہ:

سٹرنگ strCol=تار('میں کال کرتا ہوں')؛
strCol[] = 'f'؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ میں گرتا ہوں۔ 'c' کو 'f' میں تبدیل کر دیا گیا۔

stringName.at (i)

stringName.at (i) stringName [i] کی طرح ہے ، لیکن stringName.at (i) زیادہ قابل اعتماد ہے۔ مندرجہ ذیل کوڈ ظاہر کرتا ہے کہ اسے کس طرح استعمال کیا جانا چاہیے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strColپر()؛
لاگت<<چودھری<< 'n'؛

at () دراصل ایک سٹرنگ کلاس ممبر کا فنکشن ہے۔

stringName.at (i) const۔

stringName.at (i) const stringName [i] const کی طرح ہے ، لیکن stringName.at (i) const زیادہ قابل اعتماد ہے۔ stringName.at (i) const کو stringName.at (i) کے بجائے پھانسی دی جاتی ہے جب سٹرنگ آبجیکٹ مستقل سٹرنگ آبجیکٹ ہوتا ہے۔ یہ مندرجہ ذیل کوڈ میں استعمال ہوتا ہے ، مثال کے طور پر:

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strColپر()؛
لاگت<<چودھری<< 'n'؛

at () const دراصل ایک سٹرنگ کلاس ممبر کا فنکشن ہے۔

at () فنکشن کے ساتھ ایک ویلیو تفویض کرنا۔

ایک قدر کو غیر مسلسل سٹرنگ آبجیکٹ کو تفویض کیا جا سکتا ہے ، at () فنکشن کے ساتھ ، مندرجہ ذیل:

سٹرنگ strCol=تار('میں کال کرتا ہوں')؛
strColپر() = 'f'؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ میں گرتا ہوں۔

سب سکرپٹنگ کے ساتھ مسئلہ۔

سب سکرپٹنگ (انڈیکسنگ) میں مسئلہ یہ ہے کہ اگر انڈیکس حد سے باہر ہے تو غلط نتیجہ حاصل کیا جا سکتا ہے ، یا رن ٹائم پر غلطی جاری کی جا سکتی ہے۔

سامنے ()

یہ عنصر کو ہٹائے بغیر سٹرنگ آبجیکٹ کے پہلے عنصر کا حوالہ دیتا ہے۔ درج ذیل کوڈ کا آؤٹ پٹ 'I' ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strColسامنے()؛
لاگت<<چودھری<< 'n'؛

سٹرنگ آبجیکٹ سے کریکٹر نہیں ہٹایا جاتا۔

سامنے () const

جب سٹرنگ آبجیکٹ کی تعمیر const سے پہلے ہوتی ہے تو ، سامنے () کے بجائے اظہار سامنے () const کو پھانسی دی جاتی ہے۔ یہ مندرجہ ذیل کوڈ میں استعمال ہوتا ہے ، مثال کے طور پر۔

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strColسامنے()؛
لاگت<<چودھری<< 'n'؛

ایک مستقل حوالہ واپس کیا جاتا ہے۔ عنصر کو سٹرنگ آبجیکٹ سے نہیں ہٹایا جاتا ہے۔ مستقل سٹرنگ آبجیکٹ کے لیے کوئی کردار تبدیل نہیں کیا جا سکتا۔

پیچھے()

یہ عنصر کو ہٹائے بغیر سٹرنگ آبجیکٹ کے آخری عنصر کا حوالہ دیتا ہے۔ درج ذیل کوڈ کی پیداوار 'یو' ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strColپیچھے()؛
لاگت<<چودھری<< 'n'؛

back () const

جب سٹرنگ آبجیکٹ کی تعمیر const سے پہلے ہوتی ہے تو ، back () const کا اظہار back () کے بجائے کیا جاتا ہے۔ یہ مندرجہ ذیل کوڈ میں استعمال ہوتا ہے ، مثال کے طور پر۔

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
چارچودھری=strColپیچھے()؛
لاگت<<چودھری<< 'n'؛

ایک مستقل حوالہ واپس کیا جاتا ہے۔ عنصر کو سٹرنگ آبجیکٹ سے نہیں ہٹایا جاتا ہے۔

سٹرنگ کی صلاحیت

size_type صلاحیت () const noexcept۔

حروف کی کل تعداد جو سٹرنگ دوبارہ جگہ کی ضرورت کے بغیر رکھ سکتی ہے ، اس صلاحیت کے ممبر فنکشن کے ذریعے لوٹائی جاتی ہے۔ اس کے لیے ایک کوڈ طبقہ یہ ہے:

سٹرنگ strCol=تار()؛
intایک پر=strColصلاحیت()؛
لاگت<<ایک پر<< 'n'؛

میرے کمپیوٹر پر آؤٹ پٹ 15 ہے۔

ریزرو (ن)

میموری کی جگہ ہمیشہ مفت اسٹور میں دستیاب نہیں ہوتی ہے۔ اضافی جگہ پہلے سے محفوظ کی جا سکتی ہے۔ درج ذیل کوڈ کے حصے پر غور کریں:

سٹرنگ strCol=تار('محبت')؛
strColریزرو()؛
لاگت<<strColصلاحیت() << 'n'؛

میرے کمپیوٹر پر آؤٹ پٹ 15 ہے۔

size () const noexcept

یہ تار میں حروف کی تعداد لوٹاتا ہے۔ مندرجہ ذیل کوڈ واضح کرتا ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
intایک پر=strColسائز()؛
لاگت<<ایک پر<< 'n'؛

آؤٹ پٹ 10 ہے ، جس میں nul ، 0 حرف شامل نہیں ہے۔

length () const noexcept

-سائز کی طرح().
نوٹ:سائز() <=صلاحیت().

فٹ ہونے کے لئے سکڑ()

دوبارہ تقسیم کی وجہ سے صلاحیت () کو سائز () میں کم کر سکتا ہے یہ واجب نہیں ہے مندرجہ ذیل کوڈ اس کو ظاہر کرتا ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strColریزرو(12۔)؛
strColفٹ ہونے کے لئے سکڑ()؛
ints=strColسائز()؛
لاگت<<s<< 'n'؛

آؤٹ پٹ 10 ہے نہ کہ 12 یا 16۔ فنکشن باطل لوٹتا ہے۔

سائز تبدیل کریں (sz) ، سائز تبدیل کریں (sz ، ’c’)

یہ تار کا سائز بدلتا ہے۔ اگر نیا سائز پرانے سائز سے چھوٹا ہے ، تو آخر کی طرف عناصر مٹ جاتے ہیں۔ اگر نیا سائز لمبا ہے تو آخر میں کچھ ڈیفالٹ کریکٹر شامل کر دیا جاتا ہے۔ کسی خاص کردار کو شامل کرنے کے لیے ، resize () فنکشن کو دو دلائل کے ساتھ استعمال کریں۔ مندرجہ ذیل کوڈ طبقہ دو افعال کے استعمال کی وضاحت کرتا ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strColسائز تبدیل کریں()؛
لاگت<< strCol کا نیا سائز: ' <<strColسائز() << 'n'؛
سٹرنگ strCol1=تار('میں محبت کرتا ہوں'، 'اور')؛
strCol1.سائز تبدیل کریں(12۔)؛
لاگت<< strCol1 کا نیا سائز: ' <<strCol1.سائز() << 'n'؛

پیداوار یہ ہے:

strCol کا نیا سائز: 6۔
strCol1: 12 کا نیا سائز۔
فنکشن باطل لوٹتا ہے۔

واضح () نہیں۔

سٹرنگ سے تمام عناصر کو ہٹا دیتا ہے ، جیسا کہ درج ذیل کوڈ سیکشن واضح کرتا ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strColصاف()؛
لاگت<<strColسائز() << 'n'؛

آؤٹ پٹ 0 ہے۔ فنکشن باطل لوٹتا ہے۔

خالی () const noexcept۔

اگر سٹرنگ آبجیکٹ میں کوئی کریکٹر نہ ہو تو یہ سچ کے لیے 1 لوٹاتا ہے ، یا سٹرنگ آبجیکٹ خالی نہ ہونے پر غلط کے لیے 0۔ مندرجہ ذیل کوڈ اس کی وضاحت کرتا ہے:

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
لاگت<<strCol1.خالی() << 'n'؛
سٹرنگ strCol2=تار()؛
لاگت<<strCol2.خالی() << 'n'؛

پیداوار یہ ہے:


ریٹرننگ آئٹریٹرز اور سٹرنگ کلاس۔

ایک تکرار ایک پوائنٹر کی طرح ہے لیکن اس میں پوائنٹر سے زیادہ فعالیت ہے۔

شروع () کوئی بات نہیں۔

ایک تکرار کرنے والا لوٹاتا ہے جو سٹرنگ آبجیکٹ کے پہلے حرف (عنصر) کی طرف اشارہ کرتا ہے ، جیسا کہ درج ذیل کوڈ کے حصے میں ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والااسے=strColشروع کریں()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ 'I' ہے۔ نوٹ کریں کہ جس طرح اعلانیہ تکرار کرتا ہے ، اعلان کیا گیا ہے۔ تکرار کرنے والے کو واپسی کے اظہار میں ڈیفیرنس کیا جاتا ہے تاکہ قیمت حاصل کی جا سکے ، اسی طرح کہ ایک پوائنٹر کا حوالہ دیا جاتا ہے۔

start () const noexcept؛

ایک تکرار کرنے والا لوٹاتا ہے جو سٹرنگ آبجیکٹ کلیکشن کے پہلے عنصر کی طرف اشارہ کرتا ہے۔ جب آبجیکٹ کی تعمیر کانسٹسٹ سے پہلے ہوتی ہے تو ، start () const کی بجائے start () const پر عمل کیا جاتا ہے۔ اس شرط کے تحت ، آبجیکٹ میں متعلقہ عنصر کو تبدیل نہیں کیا جا سکتا۔ یہ مندرجہ ذیل کوڈ میں استعمال ہوتا ہے ، مثال کے طور پر۔

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::const_iteratorاسے=strColشروع کریں()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ 'I' ہے۔ نوٹ کریں کہ const_iterator اس بار استعمال کیا گیا ہے ، صرف تکرار کرنے والے کی بجائے ، لوٹا ہوا تکرار وصول کرنے کے لیے۔

اختتام () نہیں۔

ایک تکرار کرنے والا لوٹاتا ہے جو سٹرنگ آبجیکٹ کے آخری عنصر سے فوری طور پر اشارہ کرتا ہے۔ درج ذیل کوڈ کے حصے پر غور کریں:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والااسے=strColختم()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ کالعدم ہے ، جو کچھ بھی نہیں ہے ، کیونکہ آخری عنصر سے آگے کوئی ٹھوس عنصر نہیں ہے۔

end () const noexcept

ایک تکرار کرنے والا لوٹاتا ہے جو سٹرنگ آبجیکٹ کے آخری عنصر سے فوری طور پر اشارہ کرتا ہے۔ جب سٹرنگ آبجیکٹ کی تعمیر const سے پہلے ہوتی ہے تو ، end () const کی بجائے end () const پر عملدرآمد کیا جاتا ہے۔ درج ذیل کوڈ کے حصے پر غور کریں:

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::const_iteratorاسے=strColختم()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ کالعدم ہے۔ نوٹ کریں کہ const_iterator اس بار استعمال کیا گیا ہے ، صرف تکرار کرنے والے کی بجائے ، لوٹا ہوا تکرار وصول کرنے کے لیے۔

ریورس تکرار

یہ ممکن ہے کہ ایک تکرار کرنے والا ہو جو اصل سرے سے پہلے عنصر سے پہلے تک دہرایا جائے:

rbegin () کوئی بات نہیں۔

ایک تکرار کرنے والا لوٹاتا ہے جو سٹرنگ انسٹینٹیڈ آبجیکٹ کے آخری عنصر کی طرف اشارہ کرتا ہے ، جیسا کہ درج ذیل کوڈ سیکشن میں ہے:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::ریورس_ایٹراسے=strColشروع()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ 'یو' ہے۔ اس نوٹ کو نوٹ کریں جس طرح ریورس تکرار موصول ہوتا ہے ، اعلان کیا گیا ہے۔ تکرار کرنے والے کو واپسی کے اظہار میں ڈیفیرنس کیا جاتا ہے تاکہ قیمت حاصل کی جا سکے ، اسی طرح کہ ایک پوائنٹر کا حوالہ دیا جاتا ہے۔

rbegin () const noexcept

ایک تکرار کرنے والا لوٹاتا ہے جو سٹرنگ آبجیکٹ کے آخری عنصر کی طرف اشارہ کرتا ہے۔ جب آبجیکٹ کی تعمیر const سے پہلے ہوتی ہے تو ، rbegin () const کا اظہار rbegin () کے بجائے کیا جاتا ہے۔ اس شرط کے تحت ، آبجیکٹ میں متعلقہ عنصر کو تبدیل نہیں کیا جا سکتا۔ خصوصیت مندرجہ ذیل کوڈ میں استعمال کی گئی ہے ، مثال کے طور پر۔

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::const_reverse_iteratorاسے=strColشروع()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ 'یو' ہے۔ نوٹ کریں کہ const_reverse_iterator اس بار استعمال کیا گیا ہے ، صرف ریورس_ائٹر کے بجائے ، لوٹا ہوا تکرار وصول کرنے کے لیے۔

render () noexcept

ایک تکرار کرنے والا لوٹاتا ہے جو اسٹرنگ آبجیکٹ کے پہلے عنصر سے بالکل پہلے اشارہ کرتا ہے۔ درج ذیل کوڈ کے حصے پر غور کریں:

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::ریورس_ایٹراسے=strColبناتا ہے()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ کالعدم ہے ، جو کچھ بھی نہیں ہے ، کیونکہ پہلے عنصر سے بالکل پہلے کوئی ٹھوس عنصر نہیں ہے۔

render () const noexcept

ایک تکرار کرنے والا لوٹاتا ہے جو اسٹرنگ آبجیکٹ کے پہلے عنصر سے بالکل پہلے اشارہ کرتا ہے۔ جب آبجیکٹ کی تعمیر کانسٹسٹ سے پہلے ہوتی ہے تو ، rend () const کا اظہار rend () کے بجائے کیا جاتا ہے۔ درج ذیل کوڈ کے حصے پر غور کریں:

constسٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::const_reverse_iteratorاسے=strColبناتا ہے()؛
لاگت<< *اسے<< 'n'؛

آؤٹ پٹ کالعدم ہے۔ نوٹ کریں کہ const_reverse_iterator اس بار استعمال کیا گیا ہے ، صرف ریورس_ائٹر کے بجائے ، لوٹا ہوا تکرار وصول کرنے کے لیے۔

سٹرنگ موڈیفائرز

ایک موڈیفائر جو سٹرنگ آبجیکٹ میں ترمیم کرتا ہے ، ایک تکرار کرنے والا بھی لے سکتا ہے یا واپس کرسکتا ہے۔

لگانا

بنیادی_ سٹرنگ&آپریٹر+ =(constبنیادی_ سٹرنگ&p)

دائیں سٹرنگ آبجیکٹ کو بائیں سٹرنگ آبجیکٹ میں شامل کرتا ہے۔ مثال:

سٹرنگ strCol1=تار('میں محبت کرتا ہوں')؛
سٹرنگ strCol2=تار(' تم')؛
strCol1+ =strCol2؛
لاگت<<strCol1<< 'n'؛

نتیجہ یہ ہے کہ میں تم سے محبت کرتا ہوں۔ مت بھولنا کہ strCol1 += strCol2 ایک جیسا ہی ہے strCol1 = strCol1 +strCol2۔

basic_string & operator+= (const charT* s)

سٹرنگ آبجیکٹ کلیکشن میں سٹرنگ لفظی شامل کرتا ہے۔ مثال:

سٹرنگ strCol=تار('میں محبت کرتا ہوں')؛
strCol+ = ' تم'؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔

basic_string & operator+= (charT c)

کسی ایک حرف کو کسی شے کے تار میں شامل کرتا ہے۔ مثال:

سٹرنگ strCol=تار('مجھے آپ سے محبت ہے')؛
strCol+ = 'تم'؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔

basic_string & operator+= (initializer_list)

ایک ابتدائی فہرست شامل کرتا ہے۔ مثال:

سٹرنگ strCol=تار('میں محبت کرتا ہوں')؛
strCol+ = {''،'اور'،'یا'،'تم'،''}؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔ کریکٹر کی ابتدائی فہرست کے آخر میں nul ، 0 شامل کرنا ہمیشہ اچھا ہے۔

بنیادی_اسٹرنگ اور ضم کریں (const basic_string & str)

دلیل سٹرنگ آبجیکٹ کو مرکزی سٹرنگ آبجیکٹ میں شامل کرتا ہے۔ مثال:

سٹرنگ strCol1=تار('میں محبت کرتا ہوں')؛
سٹرنگ strCol2=تار(' تم')؛
strCol1.شامل کریں(strCol2)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔

بنیادی_ سٹرنگ اور ضم کریں (const charT* s)

مرکزی سٹرنگ میں سٹرنگ لفظی دلیل شامل کرتا ہے۔ مثال

سٹرنگ strCol=تار('میں محبت کرتا ہوں')؛
strCol=strColشامل کریں(' تم')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔

بنیادی_ سٹرنگ اور ضم کریں (ابتدائیہ_ فہرست)

ابتدائی فہرست کو جوڑتا ہے ، جو کہ ایک دلیل ہے ، مرکزی تار میں۔ مثال:

سٹرنگ strCol=تار('میں محبت کرتا ہوں')؛
strCol=strColشامل کریں({''،'اور'،'یا'،'تم'،''})؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔ ابتدائی فہرست کے آخر میں nul ، 0 حرف شامل کرنا ہمیشہ اچھا ہوتا ہے۔

بنیادی_ سٹرنگ اور ضم کریں (سائز_ ٹائپ این ، چارٹ سی)

ایک ہی حرف کا ن شامل کرتا ہے۔ مثال:

سٹرنگ strCol=تار('ٹیب')؛
strCol=strColشامل کریں(، 'یا')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: ممنوع۔

بنیادی_ سٹرنگ اور ضم کریں (const charT* s ، size_type n)

سٹرنگ کے پہلے n عناصر کو مرکزی سٹرنگ آبجیکٹ میں شامل کرتا ہے۔ مثال:

سٹرنگ strCol=تار('میں محبت کرتا ہوں')؛
strCol=strColشامل کریں(' تم بھی'، )؛
لاگت<<strCol<< 'n'؛

پیداوار یہ ہے: میں تم سے پیار کرتا ہوں۔ اگر n لفظی کی لمبائی سے زیادہ ہے تو ، ایک length_error استثناء پھینک دیا جاتا ہے۔

بنیادی_ سٹرنگ اور ضم کریں (const basic_string & str ، size_type pos ، size_type n = npos)

انڈیکس ، پوز کو مرکزی سٹرنگ میں شامل کرتا ہے۔ مثال:

سٹرنگ strCol=تار('میں محبت کرتا ہوں')؛
strCol=strColشامل کریں(کیا تم ایسا ہو '، ، )؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: میں تم سے پیار کرتا ہوں۔ ایک استثناء بھی یہاں پھینک دیا جائے گا ، بعد میں دیکھیں۔

تفویض کرنا۔

بنیادی_ سٹرنگ&تفویض(constبنیادی_ سٹرنگ&p)

دلیل سٹرنگ آبجیکٹ کو مرکزی سٹرنگ پر تفویض کرتا ہے ، وہاں موجود کسی بھی مواد کی جگہ لے لیتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
سٹرنگ strCol2=تار('اسے میری ضرورت ہے')؛
strCol1=strCol1.تفویض(strCol2)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: اسے میری ضرورت ہے۔

بنیادی_ سٹرنگ&تفویض(constچارٹ*s)

مرکزی سٹرنگ کو ایک سٹرنگ لفظی دلیل تفویض کرتا ہے ، وہاں موجود کسی بھی مواد کی جگہ لے لیتا ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strCol=strColتفویض('اسے میری ضرورت ہے')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: اسے میری ضرورت ہے۔

بنیادی_ سٹرنگ&تفویض(initializer_list<چارٹ>)

مین سٹرنگ کو ایک ابتدائی فہرست کی دلیل تفویض کرتا ہے۔،وہاں موجود کسی بھی مواد کو تبدیل کرنا۔
[سی سی لینگ='ج'فرار='سچ'چوڑائی='780']
سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strCol=strColتفویض({'ایس'،'h'،'اور'،''،'این'،'اور'،'اور'،'ڈی'،کی،''،'ایم'،'اور'،''})؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: اسے میری ضرورت ہے۔ سٹرنگ لٹریل بنانے کے لیے ، حرف کی فہرست کے آخر میں the 0 کو ہمیشہ شامل کرنا اچھا ہے۔

بنیادی_ سٹرنگ&تفویض(constچارٹ*s،size_type n)

کسی سٹرنگ کے پہلے n حروف کو مرکزی سٹرنگ کے لیے تفویض کرتا ہے ، وہاں موجود کسی بھی مواد کی جگہ لے لیتا ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strCol=strColتفویض('اسے میری ضرورت ہے'، )؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: اسے ضرورت ہے۔

بنیادی_ سٹرنگ&تفویض(size_type n،چارٹ ج۔)

مرکزی سٹرنگ پر ایک ہی حروف کے ن کی دلیل تفویض کرتا ہے ، وہاں موجود کسی بھی مواد کی جگہ لے لیتا ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strCol=strColتفویض(، 'اور')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: eeee

بنیادی_ سٹرنگ&تفویض(constبنیادی_ سٹرنگ&p،size_type پوز،
size_type n=npos)

اسٹرنگ آبجیکٹ دلیل کے n حروف تفویض کرتا ہے ، پوز سے شروع ہو کر ، مرکزی سٹرنگ تک ، وہاں موجود کسی بھی مواد کی جگہ لے لیتا ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
strCol=strColتفویض('اسے میری ضرورت ہے'، ، )؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: ضروریات ایک استثناء ڈالیں گے - بعد میں دیکھیں۔

داخل کرنا۔

بنیادی_ سٹرنگ&داخل کریں(size_type پوز، constبنیادی_ سٹرنگ&p)

انڈیکس ، پوز پر مین سٹرنگ میں سٹرنگ آبجیکٹ دلیل داخل کرتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
سٹرنگ strCol2=تار('نفرت اور')؛
strCol1=strCol1.داخل کریں(،strCol2)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: میں آپ سے نفرت اور محبت کرتا ہوں۔ ایک استثناء ڈالیں گے - بعد میں دیکھیں۔

بنیادی_ سٹرنگ&داخل کریں(size_type pos1، constبنیادی_ سٹرنگ&
p،size_type pos2،size_type n=npos)

اسٹرنگ آبجیکٹ دلیل کے پوس 2 سے لے کر مین سٹرنگ تک ، انڈیکس ، پوز 1 میں این حروف کی لمبائی داخل کرتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
سٹرنگ strCol2=تار('نفرت ، خواہش اور ضرورت')؛
strCol1=strCol1.داخل کریں(،strCol2، ، )؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: میں چاہتا ہوں اور آپ سے محبت کرتا ہوں۔

تکرار داخل کریں (const_iterator p ، charT c)

ایک خاص کردار ، جو کہ ایک دلیل ہے ، اس پوزیشن میں داخل کرتا ہے جس کی طرف تکرار کرنے والا اشارہ کرتا ہے۔ نئے داخل کردہ کردار کی پوزیشن کے لیے ایک تکرار کرنے والا لوٹاتا ہے۔

سٹرنگ strCol=تار('میں تم سے پیار کرتا ہوں')؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والااسے=strColشروع کریں()؛
++۔اسے؛ ++۔اسے؛ ++۔اسے؛ ++۔اسے؛ ++۔اسے؛ ++۔اسے؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والانیٹ ورک=strColداخل کریں(اسے، 'ڈی')؛
لاگت<< *نیٹ ورک<< 'n'؛
لاگت<<strCol<< 'n'؛

پیداوار یہ ہے:

'ڈی'

میں تم سے پیار کرتا تھا۔

تکرار داخل کریں (const_iterator p ، size_type n ، charT c)

دلیل کے ایک ہی کردار کے n داخل کرتا ہے ، پوزیشن میں ، جس کی طرف تکرار کرنے والا اشارہ کرتا ہے۔ نئے داخل کردہ وہی حروف کے آغاز کی پوزیشن کے لیے ایک تکرار کرنے والا لوٹاتا ہے۔

سٹرنگ strCol=تار('زمین میں ٹیب.')؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والااسے=strColشروع کریں()؛
++۔اسے؛ ++۔اسے؛ ++۔اسے؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والانیٹ ورک=strColداخل کریں(اسے، ، 'یا')؛
لاگت<< *نیٹ ورک<< 'n'؛
لاگت<<strCol<< 'n'؛

پیداوار یہ ہے:

'یا'

زمین میں ممنوع۔

بنیادی_ سٹرنگ&داخل کریں(size_type پوز، constچارٹ*s)

انڈیکس میں ایک دلیل سٹرنگ داخل کرتا ہے ، مرکزی سٹرنگ میں پوز۔

سٹرنگ strCol=تار('زمین میں ٹیب.')؛
strCol=strColداخل کریں(، 'اوہ')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: زمین میں ممنوع۔

بنیادی_ سٹرنگ&داخل کریں(size_type پوز، constچارٹ*s،size_type n)

دلائل سٹرنگ کے پہلے n حروف داخل کرتا ہے ، انڈیکس میں ، مرکزی سٹرنگ میں پوز۔

سٹرنگ strCol=تار('زمین میں ٹیب.')؛
strCol=strColداخل کریں(، 'اووو'، )؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: زمین میں ممنوع۔

بدل رہا ہے۔

بنیادی_ سٹرنگ&تبدیل کریں(size_type pos1،size_type n1، constبنیادی_ سٹرنگ&p))

انڈیکس ، pos1 سے مین سٹرنگ آبجیکٹ میں n1 حروف کو دلیل سٹرنگ آبجیکٹ سے بدل دیتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
سٹرنگ strCol2=تار('تم سے نفرت ہے اور')؛
strCol1=strCol1.تبدیل کریں(، ،strCol2)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: میں تم سے اور تم سے نفرت کرتا ہوں۔ ایک استثناء ڈالیں گے - بعد میں دیکھیں۔

بنیادی_ سٹرنگ&تبدیل کریں(size_type pos1،size_type n1، constبنیادی_ سٹرنگ&
p،size_type pos2،size_type n2۔=npos)

انڈیکس ، pos1 سے مین سٹرنگ آبجیکٹ میں n1 حروف کو انڈیکس ، pos2 سے دلیل سٹرنگ آبجیکٹ کے n2 حروف کے ساتھ بدل دیتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
سٹرنگ strCol2=تار('ہم اس سے اور اس سے نفرت کرتے ہیں')؛
strCol1=strCol1.تبدیل کریں(، ،strCol2، ، 12۔)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: مجھے اس سے اور تم سے نفرت ہے۔

بنیادی_ سٹرنگ&تبدیل کریں(size_type pos1،size_type n1، constچارٹ*s،
size_type n2)

انڈیکس ، pos1 سے مین سٹرنگ آبجیکٹ میں n1 حروف کو لفظی سٹرنگ دلیل کے پہلے n2 حروف کے ساتھ بدل دیتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
strCol1=strCol1.تبدیل کریں(، ، 'اس سے اور اس سے نفرت کرو'، 12۔)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: مجھے اس سے اور تم سے نفرت ہے۔

بنیادی_ سٹرنگ اور تبدیل (سائز_ ٹائپ پوز ، سائز_ ٹائپ این ، کانسٹ چارٹ* ایس)

مین سٹرنگ آبجیکٹ میں n حروف کو انڈیکس ، پوز سے لفظی سٹرنگ دلیل کے ساتھ بدل دیتا ہے۔

سٹرنگ strCol1=تار('میں تم سے پیار کرتا ہوں')؛
strCol1=strCol1.تبدیل کریں(، ، اس سے نفرت کرو اور)؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: مجھے اس سے اور تم سے نفرت ہے۔

بنیادی_ سٹرنگ&تبدیل کریں(size_type pos1،size_type n1،size_type n2۔،چارٹ ج۔)

انڈیکس ، pos1 سے مرکزی سٹرنگ آبجیکٹ میں n1 حروف کو دلیل کے اسی کردار کے n2 کے ساتھ بدل دیتا ہے۔

سٹرنگ strCol1=تار('وہاں ایک خراب ٹیبلٹ ہے۔')؛
strCol1=strCol1.تبدیل کریں(، ، ، 'یا')؛
لاگت<<strCol1<< 'n'؛

آؤٹ پٹ: وہاں ایک برا ممنوع ہے ..

تکرار مٹانا (const_iterator p)

تکرار کرنے والے کی طرف اشارہ کردہ پوزیشن پر ایک کردار کو ہٹا دیتا ہے۔ پھر تکرار پوزیشن لوٹاتا ہے ، جو اب اس کردار پر قابض ہے جو اس کردار کے آگے تھا (یا اختتام ())۔ مندرجہ ذیل کوڈ اس کی وضاحت کرتا ہے:

سٹرنگ strCol=تار('اے، بی، سی، ڈی')؛
بنیادی_ سٹرنگ<چار> ::تکرار کرنے والااسے=strColشروع کریں()؛
++۔اسے؛ ++۔اسے؛
strColمٹانا(اسے)؛
لاگت<<strCol[] << '' <<strCol[] << '
'
<<strCol[]<< 'n'؛

آؤٹ پٹ: a b d۔

بنیادی_ سٹرنگ&مٹانا(size_type پوز= ،size_type n=npos)

انڈیکس ، پوز سے n حروف کو ہٹا دیتا ہے۔

سٹرنگ strCol=تار('اے، بی، سی، ڈی')؛
strColمٹانا(، )؛
لاگت<<strCol[] << '' <<strCol[] << 'n'؛

آؤٹ پٹ: ڈی۔

باطل پش بیک (چارٹ سی)

تار کے آخر میں ایک ہی حرف شامل کرنے کے لیے:

سٹرنگ strCol=تار('اے، بی، سی، ڈی')؛
strColپیچھے دھکیلو('5')؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: abcd5۔

باطل پاپ بیک ()

آخری کردار کو واپس کیے بغیر اسے ہٹا دیتا ہے۔ سٹرنگ کا سائز 1 سے کم ہو گیا ہے۔

سٹرنگ strCol=تار('abcde')؛
strColpop_back()؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: اے بی سی ڈی

باطل تبادلہ (بنیادی_ سٹرنگ اور ے)

دو سٹرنگ اشیاء کے لیٹرلز کو تبدیل کیا جا سکتا ہے۔

سٹرنگ strCol1=تار(<ایک آئی ڈی='پوسٹ 69618 -__ DdeLink__781_3724385525'>کو>'abcde')؛
سٹرنگ strCol2=تار('1234567')؛
strCol1.تبادلہ(strCol2)؛
لاگت<<strCol1<< 'n'؛
لاگت<<strCol2<< 'n'؛

پیداوار یہ ہے:

'1234567'
'abcde'

سٹرنگ آپریشنز

const charT* c_str () const noexcept۔

سٹرنگ کے پہلے عنصر پر ایک پوائنٹر لوٹاتا ہے۔ پوائنٹر میں اضافہ کیا جا سکتا ہے۔

constسٹرنگ strCol=تار('abcde')؛
const چار*p=strColc_str()؛
لاگت<< *p<< 'n'؛
++۔p؛
لاگت<< *p<< 'n'؛

آؤٹ پٹ ہے:

کو
ب

ہیڈنگ میں دوسرے کانسٹ کی وجہ سے ، پروگرام سٹرنگ میں کسی بھی کردار کو تبدیل نہیں کر سکتا۔ تعمیر سے پہلے کانسٹ ہے۔

const charT* data () const noexcept۔

سٹرنگ کے پہلے عنصر پر ایک پوائنٹر لوٹاتا ہے۔ پوائنٹر میں اضافہ کیا جا سکتا ہے۔

constسٹرنگ strCol=تار('abcde')؛
const چار*p=strColڈیٹا()؛
لاگت<< *p<< 'n'؛
++۔p؛
لاگت<< *p<< 'n'؛

آؤٹ پٹ ہے:

کو
ب

ہیڈنگ میں دوسرے کانسٹ کی وجہ سے ، پروگرام سٹرنگ میں کسی بھی کردار کو تبدیل نہیں کر سکتا۔ تعمیر سے پہلے کانسٹ ہے۔

basic_string substr (size_type pos = 0، size_type n = npos) const۔

انڈیکس ، پوس سے شروع ہونے والی ذیلی سٹرنگ کے لیے n حروف کی سٹرنگ آبجیکٹ لوٹاتا ہے۔

constسٹرنگ strCol=تار('abcdefghij')؛
constسٹرنگ retStr=strColذیلی(، )؛
لاگت<<retStr<< 'n'؛

آؤٹ پٹ: سی ڈی ایف۔

رکن کے افعال تلاش کریں۔

size_type find (const basic_string & str، size_type pos = 0) const noexcept۔

انڈیکس ، پوز سے شروع ہونے والی سب سٹرنگ آبجیکٹ کی تلاش کرتا ہے۔ اگر مل جاتا ہے تو ، مرکزی سٹرنگ میں سب سٹرنگ کا آغاز لوٹاتا ہے۔

سٹرنگ strCol=تار('ہم دنیا ہیں!')؛
سٹرنگ strCol1=تار('')؛
intایک پر=strColمل(strCol1، )؛
لاگت<<ایک پر<< 'n'؛

آؤٹ پٹ:

انڈیکس: 7۔
واپسی -1 ، جب نہیں ملی۔

size_type find (const charT* s، size_type pos = 0) const۔

انڈیکس ، پوز سے ذیلی سٹرنگ لفظی آغاز کی تلاش میں ہے۔ اگر مل جاتا ہے تو ، مرکزی سٹرنگ میں سب سٹرنگ کا آغاز لوٹاتا ہے۔

سٹرنگ strCol=تار('ہم دنیا ہیں!')؛
intایک پر=strColمل('ہیں'، )؛
لاگت<<ایک پر<< 'n'؛

چونکہ pos = 0 پہلے سے طے شدہ ہے ، دلیل میں 0 کو خارج کیا جا سکتا تھا۔

آؤٹ پٹ: 3۔

واپسی -1 ، جب نہیں ملی۔

size_type find (const charT* s، size_type pos، size_type n) const۔

انڈیکس ، پوس سے شروع ہونے والے سب سٹرنگ کے پہلے n حروف کی تلاش کرتا ہے۔ اگر مل جاتا ہے تو ، مرکزی سٹرنگ میں سب سٹرنگ کا آغاز لوٹاتا ہے۔

سٹرنگ strCol=تار('سب سے بڑا لڑکا')؛
intایک پر=strColمل('بڑا'، ، )؛
لاگت<<ایک پر<< 'n'؛

آؤٹ پٹ: 4۔

واپسی -1 ، جب نہیں ملی۔

size_type find (charT c، size_type pos = 0) const۔

کردار کی تلاش ، c انڈیکس سے شروع ، پوز۔ اگر مل جاتا ہے تو ، مرکزی سٹرنگ میں سب سٹرنگ کا آغاز لوٹاتا ہے۔ اگر نہیں ملا تو واپس کرتا ہے -1۔

سٹرنگ strCol=تار('ہم دنیا ہیں!')؛
intایک پر=strColمل('کے ساتھ')؛
لاگت<<ایک پر<< 'n'؛

آؤٹ پٹ: -1۔

مندرجہ ذیل ریورس فائنڈ () ممبر افعال موجود ہیں:

size_type rfind(constبنیادی_ سٹرنگ&p،size_type پوز=npos) constکوئی بات نہیں؛
size_type rfind(constچارٹ*s،size_type پوز=npos) const؛
size_type rfind(constچارٹ*s،size_type پوز،size_type n) const؛
size_type rfind(چارٹ ج۔،size_type پوز=npos) const؛

ممبر کے افعال کا موازنہ کریں۔

int موازنہ (const basic_string & str) const noexcept۔

دلیل سٹرنگ آبجیکٹ کا مرکزی سٹرنگ آبجیکٹ سے موازنہ کرتا ہے۔ اگر مرکزی تار دلیل (لغت میں) سے پہلے ہوتی ہے تو یہ ایک مثبت نمبر لوٹاتا ہے۔ اگر یہ مین سٹرنگ کے بعد ہوتا ہے تو یہ منفی نمبر لوٹاتا ہے۔ اگر دونوں ڈور ایک جیسے ہیں ، تو یہ صفر لوٹتا ہے۔

سٹرنگ strCol1=تار('بھیڑ')؛
سٹرنگ strCol2=تار('لوگ')؛
intایک پر=strCol1.موازنہ کریں(strCol2)؛
لاگت<<ایک پر<< 'n'؛

آؤٹ پٹ: -13۔

int موازنہ (const charT* s) const۔

اوپر کی طرح ، لیکن دلیل ایک سٹرنگ لفظی ہے۔

سٹرنگ strCol1=تار('لوگ')؛
intایک پر=strCol1.موازنہ کریں('لوگ')؛
لاگت<<ایک پر<< 'n'؛

آؤٹ پٹ: 0۔

سٹرنگ آپریٹرز۔

یہ آپریٹرز سٹرنگ آبجیکٹ پر لاگو ہوتے ہیں اور ضروری نہیں کہ سٹرنگ لیٹرلز ہوں۔

+

دو سٹرنگ اشیاء کو جوڑتا ہے ، اور کنکٹنیشن لوٹاتا ہے۔

سٹرنگ strCol1=تار('پر رقص')؛
سٹرنگ strCol2=تار(' چاند')؛
سٹرنگ strCol=strCol1+strCol2؛
لاگت<<strCol<< 'n'؛

آؤٹ پٹ: چاند پر رقص۔

==

سچ کے لیے 1 لوٹاتا ہے ، اگر تار کی اشیاء ایک جیسی ہوں۔ اور جھوٹے کے لیے صفر ، اگر وہ نہیں ہیں۔

سٹرنگ strCol1=تار('پر رقص')؛
سٹرنگ strCol2=تار(' چاند پر')؛
بول bl=strCol1==strCol2؛
لاگت<<bl<< 'n'؛

آؤٹ پٹ: 0۔

! =

1 لوٹاتا ہے اگر سٹرنگ اشیاء ایک جیسی نہیں ہیں ، اور صفر اگر وہ ہیں۔

سٹرنگ strCol1=تار('پر رقص')؛
سٹرنگ strCol2=تار(' چاند پر')؛
بول bl=strCol1! =strCol2؛
لاگت<<bl<< 'n'؛

آؤٹ پٹ: 1۔

<

1 لوٹتا ہے ، اگر بائیں آپریینڈ لغت کے مطابق دائیں آپریشن سے کم ہے ، یا اگر نہیں ہے تو صفر۔

سٹرنگ strCol1=تار('پر رقص')؛
سٹرنگ strCol2=تار(' چاند پر')؛
بول bl=strCol1<strCol2؛
لاگت<<bl<< 'n'؛

آؤٹ پٹ: 0۔

C ++ میں عام حروف کے لیے ، بڑھتے ہوئے ترتیب میں ، نمبر بڑے حروف سے پہلے آتے ہیں ، جو چھوٹے حروف سے پہلے آتے ہیں۔ خلائی کردار صفر اور ان سب سے پہلے آتا ہے۔

C ++ مین سٹرنگ کریکٹر کی اقسام۔

چار

چار قسم اصل C ++ قسم ہے اور عام طور پر ایک کردار کو 8 بٹس میں محفوظ کرتی ہے۔

char16_t

یہ ایک کردار کو 16 بٹس میں محفوظ کرتا ہے۔

char32_t

یہ ایک کردار کو 32 بٹس میں محفوظ کرتا ہے۔

wchar_t

char16_t اور char32_t وسیع حروف ہیں۔ wchar_t ایک وسیع کردار ہے جو ملکیتی اور عمل درآمد سے متعین ہے۔

ان اقسام کو خصائص کہا جاتا ہے۔ تاہم ، C ++ ان کو تکنیکی طور پر ، خصائص کی مہارت کے طور پر حوالہ دیتا ہے۔ یہ مضمون چار قسم پر مرکوز ہے۔ دوسری اقسام کا نقطہ نظر قدرے مختلف ہے - بعد میں دیکھیں۔

دیگر سٹرنگ آپریشن ممبر افعال

دیگر سٹرنگ آپریشن افعال کے دستخط یہ ہیں:

size_type find_first_of(constبنیادی_ سٹرنگ&p،size_type پوز= ) constکوئی بات نہیں؛
size_type find_first_of(constچارٹ*s،size_type پوز،size_type n) const؛
size_type find_first_of(constچارٹ*s،size_type پوز= ) const؛
size_type find_first_of(چارٹ ج۔،size_type پوز= ) const؛
size_type find_last_of(constبنیادی_ سٹرنگ&p،size_type پوز=npos) constکوئی بات نہیں؛
size_type find_last_of(constچارٹ*s،size_type پوز،size_type n) const؛
size_type find_last_of(constچارٹ*s،size_type پوز=npos) const؛
size_type find_last_of(چارٹ ج۔،size_type پوز=npos) const؛
size_type find_first_not_of(constبنیادی_ سٹرنگ&p،size_type پوز= ) constکوئی بات نہیں؛
size_type find_first_not_of(constچارٹ*s،size_type پوز،size_type n) const؛
size_type find_first_not_of(constچارٹ*s،size_type پوز= ) const؛
size_type find_first_not_of(چارٹ ج۔،size_type پوز= ) const؛
size_type find_last_not_of(constبنیادی_ سٹرنگ&p،size_type پوز=npos) constکوئی بات نہیں؛
size_type find_last_not_of(constچارٹ*s،size_type پوز،size_type n) const؛
size_type find_last_not_of(constچارٹ*s،size_type پوز=npos) const؛
size_type find_last_not_of(چارٹ ج۔،size_type پوز=npos) const؛

نتیجہ

C ++ میں سٹرنگ لیٹرلز اور سٹرنگ آبجیکٹ ہیں۔ سٹرنگ آبجیکٹ میں تسلسل میں حروف کا مجموعہ ہوتا ہے ، جیسا کہ ترتیب میں حروف کی ایک صف۔ سٹرنگ کلیکشن اور ایک صف کے درمیان فرق یہ ہے کہ سٹرنگ کلیکشن لمبائی میں بڑھ سکتا ہے یا لمبائی میں سکڑ سکتا ہے۔ ایک سٹرنگ آبجیکٹ سٹرنگ کلاس سے فوری (تعمیر) ہوتی ہے۔ سٹرنگ آبجیکٹ ایک ڈیٹا ڈھانچہ ہوتا ہے جس میں ممبر افعال ہوتے ہیں۔ ممبر کے افعال کو آبجیکٹ کی تعمیر ، عنصر تک رسائی ، تار کی گنجائش ، تکرار دلائل اور واپسی کی اقسام کے ساتھ سٹرنگ ممبر افعال ، اور سٹرنگ موڈیفائر کے عنوانات کے تحت درجہ بندی کی جاسکتی ہے۔ سٹرنگ مساوات اور رشتہ دار آپریٹرز بھی موجود ہیں۔