Клас и обекти
Класът е набор от променливи и функции, които работят заедно; където променливите нямат присвоени стойности. Когато стойностите са присвоени на променливите, класът се превръща в обект. Различни стойности, дадени на един и същи клас, водят до различни обекти; тоест различните обекти са един и същи клас с различни стойности. Създаването на обект от клас се казва за създаване на обект.
Името, низът, е клас. Обект, създаден от низовия клас, има име, избрано от програмист.
Функция, която принадлежи на класа, е необходима за създаване на обект от класа. В C ++ тази функция има същото име като името на класа. Обектите, създадени (създадени) от класа, имат различни имена, дадени им от програмиста.
Създаване на обект от клас означава конструиране на обекта; това също означава създаване на екземпляр.
Програма на C ++, която използва низовия клас, започва със следните редове в горната част на файла:
#включва#включва
използвайки пространство за имена std;
Първият ред е за вход/изход. Вторият ред е да позволи на програмата да използва всички функции на низовия клас. Третият ред позволява на програмата да използва имената в стандартното пространство от имена.
Претоварване на функция
Когато два или повече различни подписи на функции имат едно и също име, това име се казва претоварено. Когато се извика една функция, броят и видът на аргументите определят коя функция се изпълнява.
Строителство
низ ()
Следното изявление конструира низ с нулева дължина без знак.
Той започва с името на класа (тип обект), низ. Следва името на низа на обекта, дадено от програмиста. Операторът за присвояване следва; след това името на конструктора с празни скоби. Тук strCol е създаден обект с всички членове на данни (свойства) и функции -членове (методи).
низ (str)
Това е подобно на горното, но приема или низов литерал, или идентификатор като аргумент в конструктора. Следното изявление илюстрира това:
Конструкция със списък на инициализатори
Следният код илюстрира това:
низ strCol=низ({'Аз','','the','или','v','И','','и','или','ти',' 0'});Низовият буквал е Обичам те. Обърнете внимание на символа nul в края на списъка с инициализатори.
низ (str, n)
Това образува низова колекция от първите n знака на друг низ. Следният код илюстрира това:
charстр[] = 'Обичам те';низ strCol=низ(стр, 6);
цена<<strCol<< 'н';
Резултатът е Обичам с първите 6 знака от Обичам те. Запомнете: единичното пространство е символ.
низ (str, pos, n)
Това формира низ от n символа, започвайки от нулевата индексирана позиция, pos, на друг низ. Следният код илюстрира това:
charстр[] = 'Обичам те';низ strCol=низ(стр, 2, 4);
цена<<strCol<< 'н';
Резултатът е, любов.
За горните два случая, ако n е по -голямо от размера на низа, се изхвърля изключението out_of_range - вижте по -късно.
низ (n, ‘c’)
Образува колекция от n знака, където всички знаци са еднакви. Обмисли,
низ strCol=низ(5,'И');цена<<strCol<< 'н';
Изходът е, eeeee, 5 e's.
Присвояване на низ
Низ може да бъде присвоен, както следва, след като е декларирал и двата низа:
низ strCol1=низ('Обичам те');низ strCol2;
strCol2=strCol1;
цена<<strCol2<< 'н';
Резултатът е, обичам те.
Изграждане с Iterator
Итераторът предоставя общо представяне на сканирането чрез стойностите на колекция. Синтаксис за създаване на низ с итератор е:
шаблон<клас InputIterator>basic_string(InputIterator започва,InputIterator край, constРазпределител&
да се=Разпределител());
Това конструира низ за диапазона [начало, край) - вижте подробности по -късно.
Унищожаване на низ
За да унищожите низ, просто го оставете да излезе извън обхвата.
Достъп до елемента от низовия клас
Инстанциран низов обект може да бъде подзаписан (индексиран) като масив. Преброяването на индекса започва от нула.
stringName [i]
Операцията stringName [i] връща препратка към символа (елемент) в ithиндекс на колекцията от знаци. Следният код извежда v:
низ strCol=низ('Обичам те');charгл=strCol[4];
цена<<гл<< 'н';
stringName [i] const
Операцията stringName [i] const се изпълнява вместо stringName [i], когато низовият обект е постоянен обект. Използва се например в следния код:
constниз strCol=низ('Обичам те');charгл=strCol[4];
цена<<гл<< 'н';
Изразът връща постоянна препратка към ithелемент на низовия обект. Нито един от елементите на низа не може да бъде променен.
Присвояване на знак с индекс
Символ може да бъде присвоен на неконстантален низ от обект, както следва:
низ strCol=низ('Обаждам се');strCol[2] = 'f';
цена<<strCol<< 'н';
Изходът пада. „C“ беше променено на „f“.
stringName.at (i)
stringName.at (i) е подобен на stringName [i], но stringName.at (i) е по -надежден. Следният код показва как трябва да се използва:
низ strCol=низ('Обичам те');charгл=strCol.при(4);
цена<<гл<< 'н';
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=низ('Обичам те');charгл=strCol.при(4);
цена<<гл<< 'н';
at () const всъщност е функция член на низ.
Присвояване на стойност с функцията at ()
Стойност може да бъде присвоена на неконстантален низов обект с функцията at (), както следва:
низ strCol=низ('Обаждам се');strCol.при(2) = 'f';
цена<<strCol<< 'н';
Изходът пада.
Проблем с под-скриптове
Проблемът с под-скриптове (индексиране) е, че ако индексът е извън обхвата, може да се получи грешен резултат или да се издаде грешка по време на изпълнение.
отпред ()
Това връща препратка към първия елемент на низовия обект, без да се премахва елементът. Изходът на следния код е „I“.
низ strCol=низ('Обичам те');charгл=strCol.отпред();
цена<<гл<< 'н';
Символът не се премахва от низовия обект.
front () const
Когато конструкцията на низовия обект се предхожда от const, изразът front () const се изпълнява вместо front (). Използва се например в следния код.
constниз strCol=низ('Обичам те');charгл=strCol.отпред();
цена<<гл<< 'н';
Връща се постоянна справка. Елементът не се премахва от низовия обект. Не може да се променя символ за обект с постоянен низ.
обратно()
Това връща препратка към последния елемент на низовия обект, без да се премахва елементът. Изходът на следния код е „u“.
низ strCol=низ('Обичам те');charгл=strCol.обратно();
цена<<гл<< 'н';
back () const
Когато конструкцията на низовия обект се предхожда от const, изразът back () const се изпълнява вместо back (). Използва се например в следния код.
constниз strCol=низ('Обичам те');charгл=strCol.обратно();
цена<<гл<< 'н';
Връща се постоянна справка. Елементът не се премахва от низовия обект.
Капацитет на низовете
size_type capacity () const noexcept
Общият брой знаци, които низът може да съдържа без да изисква преразпределение, се връща от тази функция член на капацитета. Кодов сегмент за това е:
низ strCol=низ();intникой=strCol.капацитет();
цена<<никой<< 'н';
Изходът е 15 на моя компютър.
резерв (n)
Мястото за памет не винаги е налично в безплатния магазин. Допълнително място може да се резервира предварително. Помислете за следния кодов сегмент:
низ strCol=низ('любов');strCol.резерв(6);
цена<<strCol.капацитет() << 'н';
Изходът е 15 на моя компютър.
size () const noexcept
Това връща броя на знаците в низа. Следният код илюстрира:
низ strCol=низ('Обичам те');intникой=strCol.размер();
цена<<никой<< 'н';
Изходът е 10, който не включва нула, 0 знака.
length () const noexcept
-същото като размера().Забележка:размер() <=капацитет().
смали до пасване()
Може да намали капацитета () до size (), като предизвика преразпределение; не е задължително. Следният код демонстрира това:
низ strCol=низ('Обичам те');strCol.резерв(12);
strCol.смали до пасване();
intс=strCol.размер();
цена<<с<< 'н';
Изходът е 10, а не 12 или 16. Функцията връща void.
преоразмеряване (sz), преоразмеряване (sz, 'c')
Това променя размера на низа. Ако новият размер е по -малък от стария, елементите към края се изтриват. Ако новият размер е по -дълъг, тогава към края се добавя някакъв символ по подразбиране. За да добавите определен символ, използвайте функцията resize () с два аргумента. Следният кодов сегмент илюстрира използването на двете функции:
низ strCol=низ('Обичам те');strCol.преоразмеряване(6);
цена<< 'Нов размер на strCol:' <<strCol.размер() << 'н';
низ strCol1=низ('Обичам', 'И');
strCol1.преоразмеряване(12);
цена<< 'Нов размер на strCol1:' <<strCol1.размер() << 'н';
Изходът е:
Нов размер на strCol: 6Нов размер на strCol1: 12
Функцията връща void.
clear () noexcept
Премахва всички елементи от низ, както илюстрира следния кодов сегмент:
низ strCol=низ('Обичам те');strCol.ясно();
цена<<strCol.размер() << 'н';
Изходът е 0. Функцията връща void.
празен () const noexcept
Това връща 1 за true, ако няма символ в низовия обект, или 0 за false, ако обектът на низ не е празен. Следният код илюстрира това:
низ strCol1=низ('Обичам те');цена<<strCol1.празна() << 'н';
низ strCol2=низ();
цена<<strCol2.празна() << 'н';
Изходът е:
01
Връщащи се итератори и низовия клас
Итераторът е като показалец, но има повече функционалност от показалеца.
begin () noexcept
Връща итератор, който сочи към първия знак (елемент) на низовия обект, както в следния кодов сегмент:
низ strCol=низ('Обичам те');basic_string<char> ::итераторiter=strCol.започнете();
цена<< *iter<< 'н';
Изходът е „I“. Обърнете внимание на начина, по който е декларирана декларацията, която получава итератора. Итераторът се пренасочва в обратен израз, за да се получи стойността, по същия начин, по който се пренасочва указател.
begin () const noexcept;
Връща итератор, който сочи към първия елемент от колекцията низови обекти. Когато конструирането на обекта се предхожда от const, изразът begin () const се изпълнява вместо begin (). При това условие съответният елемент в обекта не може да бъде променен. Използва се например в следния код.
constниз strCol=низ('Обичам те');basic_string<char> ::const_iteratoriter=strCol.започнете();
цена<< *iter<< 'н';
Изходът е „I“. Обърнете внимание, че този път const_iterator е бил използван вместо само итератор, за да получи върнатия итератор.
end () noexcept
Връща итератор, който сочи непосредствено от последния елемент на низовия обект. Помислете за следния кодов сегмент:
низ strCol=низ('Обичам те');basic_string<char> ::итераторiter=strCol.край();
цена<< *iter<< 'н';
Изходът е нулев, което е нищо, тъй като няма последен елемент извън последния елемент.
end () const noexcept
Връща итератор, който сочи непосредствено от последния елемент на низовия обект. Когато конструкцията на низовия обект се предхожда от const, изразът end () const се изпълнява вместо end (). Помислете за следния кодов сегмент:
constниз strCol=низ('Обичам те');basic_string<char> ::const_iteratoriter=strCol.край();
цена<< *iter<< 'н';
Изходът е нулев. Обърнете внимание, че този път const_iterator е бил използван вместо само итератор, за да получи върнатия итератор.
Обратна итерация
Възможно е да има итератор, който да повтаря от действителния край до точно преди първия елемент:
rbegin () noexcept
Връща итератор, който сочи към последния елемент на низовия обект, както в следния кодов сегмент:
низ strCol=низ('Обичам те');basic_string<char> ::обратен_ литераторiter=strCol.rbegin();
цена<< *iter<< 'н';
Изходът е „u“. Забележете начина, по който е декларирана декларацията, която получава обратния итератор. Итераторът се пренасочва в обратен израз, за да се получи стойността, по същия начин, по който се пренасочва указател.
rbegin () const noexcept;
Връща итератор, който сочи към последния елемент на низовия обект. Когато конструкцията на обекта е предшествана от const, изразът rbegin () const се изпълнява вместо rbegin (). При това условие съответният елемент в обекта не може да бъде променен. Функцията се използва например в следния код.
constниз strCol=низ('Обичам те');basic_string<char> ::const_reverse_iteratoriter=strCol.rbegin();
цена<< *iter<< 'н';
Изходът е „u“. Имайте предвид, че този път const_reverse_iterator е бил използван, вместо просто reverse_iterator, за да получи върнатия итератор.
render () noexcept
Връща итератор, който сочи точно преди първия елемент на низовия обект. Помислете за следния кодов сегмент:
низ strCol=низ('Обичам те');basic_string<char> ::обратен_ литераторiter=strCol.прави();
цена<< *iter<< 'н';
Изходът е нулев, което е нищо, тъй като няма конкретен елемент точно преди първия елемент.
render () const noexcept
Връща итератор, който сочи точно преди първия елемент на низовия обект. Когато конструирането на обекта се предхожда от const, изразът rend () const се изпълнява вместо rend (). Помислете за следния кодов сегмент:
constниз strCol=низ('Обичам те');basic_string<char> ::const_reverse_iteratoriter=strCol.прави();
цена<< *iter<< 'н';
Изходът е нулев. Имайте предвид, че този път const_reverse_iterator е бил използван, вместо просто reverse_iterator, за да получи върнатия итератор.
Модификатори на низове
Модификатор, който променя низовия обект, може също да вземе или върне итератор.
Прибавяне
basic_string&оператор+ =(constbasic_string&стр)Добавя десния низов обект към левия низ. Пример:
низ strCol1=низ('Обичам');низ strCol2=низ(' Вие');
strCol1+ =strCol2;
цена<<strCol1<< 'н';
Резултатът е, че те обичам. Не забравяйте, че strCol1 += strCol2 е същото като strCol1 = strCol1 +strCol2.
basic_string & operator+= (const charT* s)
Добавя низов литерал към колекция от низови обекти. Пример:
низ strCol=низ('Обичам');strCol+ = ' Вие';
цена<<strCol<< 'н';
Резултат: Обичам те.
basic_string & operator+= (charT c)
Добавя един символ към низ от обект. Пример:
низ strCol=низ('Обичам те');strCol+ = 'ти';
цена<<strCol<< 'н';
Резултат: Обичам те.
basic_string & operator+= (initializer_list)
Добавя списък с инициализатори. Пример:
низ strCol=низ('Обичам');strCol+ = {'','и','или','ти',' 0'};
цена<<strCol<< 'н';
Резултат: Обичам те. Винаги е добре да добавите nul, 0 в края на списък за инициализация на символи.
basic_string & append (const basic_string & str)
Добавя обекта на аргументен низ към основния низов обект. Пример:
низ strCol1=низ('Обичам');низ strCol2=низ(' Вие');
strCol1.добавям(strCol2);
цена<<strCol1<< 'н';
Резултат: Обичам те.
basic_string & append (const charT* s)
Добавя аргумент за низов литерал към основния низ. Пример
низ strCol=низ('Обичам');strCol=strCol.добавям(' Вие');
цена<<strCol<< 'н';
Резултат: Обичам те.
basic_string & append (initializer_list)
Добавя списъка на инициализатора, който е аргумент, към основния низ. Пример:
низ strCol=низ('Обичам');strCol=strCol.добавям({'','и','или','ти',' 0'});
цена<<strCol<< 'н';
Резултат: Обичам те. Винаги е добре да добавите символа nul, 0 в края на списъка с инициализатори.
basic_string & append (size_type n, charT c)
Добавя n от същия знак. Пример:
низ strCol=низ('раздел');strCol=strCol.добавям(2, 'или');
цена<<strCol<< 'н';
Изход: табу.
basic_string & append (const charT* s, size_type n)
Добавя първите n елемента на низов литерал към основния низов обект. Пример:
низ strCol=низ('Обичам');strCol=strCol.добавям('ти толкова', 4);
цена<<strCol<< 'н';
Резултатът е: Обичам те. Ако n е по -голямо от дължината на литерала, се изхвърля изключение length_error.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
Добавя n знака от индекса, pos към основния низ. Пример:
низ strCol=низ('Обичам');strCol=strCol.добавям(толкова ли си, 2, 4);
цена<<strCol<< 'н';
Резултат: Обичам те. Тук ще бъде направено изключение, вижте по -късно.
Присвояване
basic_string&възлагам(constbasic_string&стр)Присвоява обекта на аргументен низ на основния низ, като замества съдържанието, което е там.
низ strCol1=низ('Обичам те');низ strCol2=низ('Тя има нужда от мен');
strCol1=strCol1.възлагам(strCol2);
цена<<strCol1<< 'н';
Резултат: Тя има нужда от мен.
basic_string&възлагам(constcharT*с)Присвоява аргумент за низов литерал на основния низ, като замества всяко съдържание, което е там.
низ strCol=низ('Обичам те');strCol=strCol.възлагам('Тя има нужда от мен');
цена<<strCol<< 'н';
Резултат: Тя има нужда от мен.
basic_string&възлагам(initializer_list<charT>)Присвоява аргумент за списък на инициализатор на основния низ,замяна на съдържанието, което е там.
[cc lang='° С'избягал='вярно'ширина='780']
низ strCol=низ('Обичам те');
strCol=strCol.възлагам({'С','h','И','','н','И','И','д','с','','аз','И',' 0'});
цена<<strCol<< 'н';
Резултат: Тя има нужда от мен. Добре е винаги да добавяте nul, 0 в края на списъка с символи, за да образувате низов литерал.
basic_string&възлагам(constcharT*с,размер_тип n)Присвоява първите n знака на аргумент за низов литерал на основния низ, като замества всяко съдържание, което е там.
низ strCol=низ('Обичам те');strCol=strCol.възлагам('Тя има нужда от мен', 9);
цена<<strCol<< 'н';
Резултат: Тя се нуждае.
basic_string&възлагам(размер_тип n,диаграма c)Присвоява аргумент от n от същите символи на основния низ, като замества всяко съдържание, което е там.
низ strCol=низ('Обичам те');strCol=strCol.възлагам(4, 'И');
цена<<strCol<< 'н';
Изход: eeee
basic_string&възлагам(constbasic_string&стр,size_type поз,размер_тип n=npos)
Присвоява n знака на аргумент на низов обект, започвайки от pos, към основния низ, замествайки съдържанието, което е там.
низ strCol=низ('Обичам те');strCol=strCol.възлагам('Тя има нужда от мен', 4, 5);
цена<<strCol<< 'н';
Изход: нужди. Бих хвърлил изключение - вижте по -късно.
Вмъкване
basic_string&вмъкване(size_type поз, constbasic_string&стр)Вмъква аргумента на низовия обект в основния низ, в индекс, поз.
низ strCol1=низ('Обичам те');низ strCol2=низ('омраза и');
strCol1=strCol1.вмъкване(2,strCol2);
цена<<strCol1<< 'н';
Резултат: Мразя и те обичам. Бих хвърлил изключение - вижте по -късно.
basic_string&вмъкване(size_type pos1, constbasic_string&стр,size_type pos2,размер_тип n=npos)
Вмъква дължина от n знака от pos2 на аргумент на низов обект, към основния низ, в индекс, pos1.
низ strCol1=низ('Обичам те');низ strCol2=низ(„омраза, желание и нужда“);
strCol1=strCol1.вмъкване(2,strCol2, 6, 9);
цена<<strCol1<< 'н';
Резултат: Искам и те обичам.
вмъкване на итератор (const_iterator p, charT c)
Вмъква определен символ, който е аргумент, в позицията, посочена от итератора. Връща итератор за позицията на новоинсталирания знак.
низ strCol=низ('Обичам те');basic_string<char> ::итераторiter=strCol.започнете();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<char> ::итератормрежа=strCol.вмъкване(iter, 'д');
цена<< *мрежа<< 'н';
цена<<strCol<< 'н';
Изходът е:
'д'
обичах те
вмъкване на итератор (const_iterator p, size_type n, charT c)
Вмъква n от същия характер на аргумента в позицията, посочена от итератора. Връща итератор за позицията на началото на ново вмъкнатите същите знаци.
низ strCol=низ(„Таб в земята“.);basic_string<char> ::итераторiter=strCol.започнете();
++iter; ++iter; ++iter;
basic_string<char> ::итератормрежа=strCol.вмъкване(iter, 2, 'или');
цена<< *мрежа<< 'н';
цена<<strCol<< 'н';
Изходът е:
'или'
Табу в земята.
basic_string&вмъкване(size_type поз, constcharT*с)Вмъква литерален аргументен низ в индекса, pos в основния низ.
низ strCol=низ(„Таб в земята“.);strCol=strCol.вмъкване(3, 'оо');
цена<<strCol<< 'н';
Резултат: Табу в земята.
basic_string&вмъкване(size_type поз, constcharT*с,размер_тип n)Вмъква първите n знака от литералния аргументен низ, в индекса, pos в основния низ.
низ strCol=низ(„Таб в земята“.);strCol=strCol.вмъкване(3, 'oooo', 2);
цена<<strCol<< 'н';
Резултат: Табу в земята.
Подмяна
basic_string&замени(size_type pos1,размер_тип n1, constbasic_string&стр))Заменя n1 знака в основния низов обект от index, pos1, с аргументен низов обект.
низ strCol1=низ('Обичам те');низ strCol2=низ('мразя те и');
strCol1=strCol1.замени(2, 4,strCol2);
цена<<strCol1<< 'н';
Резултат: Мразя теб и теб. Бих хвърлил изключение - вижте по -късно.
basic_string&замени(size_type pos1,размер_тип n1, constbasic_string&стр,size_type pos2,размер_тип n2=npos)
Заменя n1 знака в основния низов обект от индекса, pos1, с n2 знака на обекта от аргументен низ от индекса, pos2.
низ strCol1=низ('Обичам те');низ strCol2=низ('мразим него и нея');
strCol1=strCol1.замени(2, 4,strCol2, 3, 12);
цена<<strCol1<< 'н';
Резултат: Мразя него и теб.
basic_string&замени(size_type pos1,размер_тип n1, constcharT*с,размер_тип n2)
Заменя n1 знака в основния низов обект от индекса, pos1, с първите n2 знака от аргумента на литералния низ.
низ strCol1=низ('Обичам те');strCol1=strCol1.замени(2, 4, 'мразя него и нея', 12);
цена<<strCol1<< 'н';
Резултат: Мразя него и теб.
basic_string & replace (size_type pos, size_type n, const charT* s)
Заменя n знака в основния низов обект от index, pos, с литералния аргумент низ.
низ strCol1=низ('Обичам те');strCol1=strCol1.замени(2, 4, 'мразя го и');
цена<<strCol1<< 'н';
Резултат: Мразя него и теб.
basic_string&замени(size_type pos1,размер_тип n1,размер_тип n2,диаграма c)Заменя n1 знака в основния низов обект от индекса, pos1, с n2 от същия символ на аргумента.
низ strCol1=низ(„Там има лош таблет.“);strCol1=strCol1.замени(9, 3, 2, 'или');
цена<<strCol1<< 'н';
Изход: Лошо табу там ..
изтриване на итератор (const_iterator p)
Премахва знак в позицията, посочена от итератора; след това връща позицията на итератора, която сега е заета от знака, който е бил до този знак (или end ()). Следният код илюстрира това:
низ strCol=низ('abcd');basic_string<char> ::итераторiter=strCol.започнете();
++iter; ++iter;
strCol.изтрива(iter);
цена<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< 'н';
Изходът: a b d
basic_string&изтрива(size_type поз= 0,размер_тип n=npos)Премахва n знака от индекса, поз.
низ strCol=низ('abcd');strCol.изтрива(1, 2);
цена<<strCol[0] << '' <<strCol[1] << 'н';
Изход: a d
void push_back (charT c)
За да добавите един знак в края на низа:
низ strCol=низ('abcd');strCol.избутвам('5');
цена<<strCol<< 'н';
Изход: abcd5
void pop_back ()
Премахва последния знак, без да го връща. Размерът на низа се намалява с 1.
низ strCol=низ('а б В Г Д');strCol.pop_back();
цена<<strCol<< 'н';
Изход: abcd
невалидна суап (basic_string & s)
Литералите на два низови обекта могат да бъдат разменени.
низ strCol1=низ(<идентификатор='post-69618 -__ DdeLink__781_3724385525'>да се>'а б В Г Д');низ strCol2=низ('1234567');
strCol1.размяна(strCol2);
цена<<strCol1<< 'н';
цена<<strCol2<< 'н';
Изходът е:
'1234567''а б В Г Д'
Низови операции
const charT* c_str () const noexcept
Връща указател към първия елемент на низа. Указателят може да бъде увеличен.
constниз strCol=низ('а б В Г Д');const char*стр=strCol.c_str();
цена<< *стр<< 'н';
++стр;
цена<< *стр<< 'н';
Изходът е:
да себ
Поради втория const в заглавието, програмата не може да промени никакъв знак в низа. Изграждането е предшествано от const.
const charT* данни () const noexcept
Връща указател към първия елемент на низа. Указателят може да бъде увеличен.
constниз strCol=низ('а б В Г Д');const char*стр=strCol.данни();
цена<< *стр<< 'н';
++стр;
цена<< *стр<< 'н';
Изходът е:
да себ
Поради втория const в заглавието, програмата не може да промени никакъв знак в низа. Изграждането е предшествано от const.
основна_струна substr (размер_тип pos = 0, размер_тип n = npos) const
Връща низов обект от n знака за подниза, започващ от индекса, поз.
constниз strCol=низ('abcdefghij');constниз retStr=strCol.подстр(2, 4);
цена<<retStr<< 'н';
Изход: cdef
find () Членски функции
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Търси обект на подниза, започващ от индекса, поз. Ако бъде намерен, връща началото на подниза в основния низ.
низ strCol=низ('Ние сме светът!');низ strCol1=низ('the');
intникой=strCol.намирам(strCol1, 2);
цена<<никой<< 'н';
Изход:
индекс: 7Връща -1, когато не е намерен.
size_type find (const charT* s, size_type pos = 0) const
Търси литерал на подниза, започващ от индекса, поз. Ако бъде намерен, връща началото на подниза в основния низ.
низ strCol=низ('Ние сме светът!');intникой=strCol.намирам('са', 0);
цена<<никой<< 'н';
Тъй като pos = 0 е по подразбиране, 0 в аргумента можеше да бъде пропуснато.
Изход: 3
Връща -1, когато не е намерен.
size_type find (const charT* s, size_type pos, size_type n) const
Търси първите n знака на поднизовия литерал, започващ от индекса, поз. Ако бъде намерен, връща началото на подниза в основния низ.
низ strCol=низ('Най -голямото момче');intникой=strCol.намирам('по -голям', 1, 3);
цена<<никой<< 'н';
Изход: 4
Връща -1, когато не е намерен.
size_type find (charT c, size_type pos = 0) const
Търси знака, c започващ от индекса, поз. Ако бъде намерен, връща началото на подниза в основния низ. Ако не бъде намерен, връща -1.
низ strCol=низ('Ние сме светът!');intникой=strCol.намирам('С');
цена<<никой<< 'н';
Изход: -1
Съществуват следните функции на обратната функция find ():
size_type rfind(constbasic_string&стр,size_type поз=npos) constбез изключение;size_type rfind(constcharT*с,size_type поз=npos) const;
size_type rfind(constcharT*с,size_type поз,размер_тип n) const;
size_type rfind(диаграма c,size_type поз=npos) const;
Сравнение на функциите на членове
int compare (const basic_string & str) const noexcept
Сравнява обекта на аргументен низ с основния низов обект. Ако основният низ се появи преди аргумента (в речника), той връща положително число. Ако се появи след основния низ, връща отрицателно число. Ако двата низа са еднакви, връща нула.
низ strCol1=низ('тълпа');низ strCol2=низ('хора');
intникой=strCol1.сравни(strCol2);
цена<<никой<< 'н';
Изход: -13
int сравни (const charT* s) const
Същото като по -горе, но аргументът е низов литерал.
низ strCol1=низ('хора');intникой=strCol1.сравни('хора');
цена<<никой<< 'н';
Изход: 0
Низови оператори
Тези оператори са приложими за низови обекти, а не непременно за низови литерали.
+
Свързва два низови обекта и връща конкатенацията.
низ strCol1=низ('танцува');низ strCol2=низ(' Луната');
низ strCol=strCol1+strCol2;
цена<<strCol<< 'н';
Резултат: танци на Луната.
==
Връща 1 за true, ако низовите обекти са еднакви; и нула за невярно, ако не са.
низ strCol1=низ('танцува');низ strCol2=низ(' на Луната');
bool bl=strCol1==strCol2;
цена<<бл<< 'н';
Изход: 0
! =
Връща 1, ако низовите обекти не са еднакви, и нула, ако са.
низ strCol1=низ('танцува');низ strCol2=низ(' на Луната');
bool bl=strCol1! =strCol2;
цена<<бл<< 'н';
Изход: 1
<
Връща 1, ако левият операнд е по -малък от десния операнд според речника, или нула, ако не е.
низ strCol1=низ('танцува');низ strCol2=низ(' на Луната');
bool bl=strCol1<strCol2;
цена<<бл<< 'н';
Изход: 0
За обикновените знаци в C ++, във възходящ ред, цифрите идват преди главни букви, които идват преди малки букви. Пробелът е преди нулата и всички те.
C ++ Основни типове символни низове
char
Типът char е оригиналният C ++ тип и обикновено съхранява знак в 8 бита.
char16_t
Това съхранява знак в 16 бита.
char32_t
Това съхранява знак в 32 бита.
wchar_t
char16_t и char32_t са широки знаци. wchar_t е широк символ, който е собственост и е дефиниран за изпълнение.
Тези видове се наричат черти. С ++ обаче ги нарича технически специализации на черти. Тази статия се фокусира върху типа char. Подходът към другите видове е малко по -различен - вижте по -късно.
Други функции на член на операция на низ
Подписите на други функции за низови операции са:
size_type find_first_of(constbasic_string&стр,size_type поз= 0) constбез изключение;size_type find_first_of(constcharT*с,size_type поз,размер_тип n) const;
size_type find_first_of(constcharT*с,size_type поз= 0) const;
size_type find_first_of(диаграма c,size_type поз= 0) const;
size_type find_last_of(constbasic_string&стр,size_type поз=npos) constбез изключение;
size_type find_last_of(constcharT*с,size_type поз,размер_тип n) const;
size_type find_last_of(constcharT*с,size_type поз=npos) const;
size_type find_last_of(диаграма c,size_type поз=npos) const;
size_type find_first_not_of(constbasic_string&стр,size_type поз= 0) constбез изключение;
size_type find_first_not_of(constcharT*с,size_type поз,размер_тип n) const;
size_type find_first_not_of(constcharT*с,size_type поз= 0) const;
size_type find_first_not_of(диаграма c,size_type поз= 0) const;
size_type find_last_not_of(constbasic_string&стр,size_type поз=npos) constбез изключение;
size_type find_last_not_of(constcharT*с,size_type поз,размер_тип n) const;
size_type find_last_not_of(constcharT*с,size_type поз=npos) const;
size_type find_last_not_of(диаграма c,size_type поз=npos) const;
Заключение
C ++ има низови литерали и низови обекти. Низовият обект има колекция от знаци в последователност, подобна на масив от символи в последователност. Разликата между низовата колекция и масива е, че колекцията от низове може да нараства по дължина или да се свива по дължина. Низов обект се създава (конструира) от низов клас. Низовият обект е структура от данни с функции -членове. Членските функции могат да бъдат класифицирани под заглавията на конструиране на обекти, достъп до елемент, капацитет на низ, функции на член на низ с аргументи на итератор и типове връщане и модификатори на низ. Съществуват и оператори за равенство на низове и релационни оператори.