Как использовать строковый класс в C++

использовать строковый класс в C++ Программирование и разработка

использовать строковый класс в C++

Строковый литерал — это последовательность символов в указателе константного массива, оканчивающаяся нулевым символом \ 0. При идентификации переменной строковый литерал не может действительно уменьшаться или увеличиваться в длине. Многие операции нельзя выполнить со строковым литералом. Итак, нужен строковый класс. Строковый класс C ++ предназначен для структуры данных, набора символов в последовательности, что позволяет функциям-членам и операторам воздействовать на символы. Строковый класс допускает больше манипуляций с соответствующим строковым литералом, чем просто строковый литерал. Чтобы понять эту статью, вам необходимо хорошо знать строковый литерал.

Класс и объекты

Класс — это набор переменных и функций, которые работают вместе; где переменным не присвоены значения. Когда переменным присваиваются значения, класс становится объектом. Различные значения, присвоенные одному и тому же классу, приводят к разным объектам; то есть разные объекты относятся к одному классу с разными значениями. Считается, что создание объекта из класса создает экземпляр объекта.

Имя, строка, — это класс. Объект, созданный из строкового класса, имеет имя, выбранное программистом.

Функция, принадлежащая классу, необходима для создания экземпляра объекта из класса. В C ++ эта функция имеет то же имя, что и имя класса. Объекты, созданные (экземпляры) из класса, имеют разные имена, данные им программистом.

Создание объекта из класса означает создание объекта; это также означает создание экземпляра.

Программа на C ++, использующая строковый класс, начинается со следующих строк вверху файла:

#include <iostream>
#include <string>
using namespace std;

Первая строка предназначена для ввода / вывода. Вторая строка позволяет программе использовать все возможности строкового класса. Третья строка позволяет программе использовать имена в стандартном пространстве имен.

Перегрузка функции

Когда две или более разных сигнатур функций имеют одно и то же имя, это имя считается перегруженным. Когда вызывается одна функция, количество и тип аргументов определяют, какая функция будет выполняться.

Construction

string ()
Следующий оператор создает строку нулевой длины без символа.

string strCol = string();

Он начинается с названия класса (типа объекта), строки. За ним следует имя строки объекта, данное программистом. Далее следует оператор присваивания; затем имя конструктора с пустыми скобками. Здесь strCol — это созданный объект со всеми элементами данных (свойствами) и функциями-членами (методами).
string (str)
Это похоже на приведенное выше, но принимает либо строковый литерал, либо идентификатор в качестве аргумента в конструкторе. Следующее утверждение иллюстрирует это:

string strCol = string(«I love you»);

Конструкция со списком инициализаторов

Следующий код иллюстрирует это:

string strCol = string({‘I’,‘ ‘,‘l’,‘o’,‘v’,‘e’,‘ ‘,‘y’,‘o’,‘u’,\0});

Строковый литерал — «Я люблю тебя». Обратите внимание на символ нуля в конце списка инициализаторов.

string(str, n)

Это формирует набор строк из первых n символов другой строки. Следующий код иллюстрирует это:

char str[] = «I love you»;
string strCol = string(str, 6);
cout << strCol << \n;

Результатом будет «Я люблю» с первыми 6 символами из «Я люблю тебя». Помните: одиночный пробел — это символ.

string(str, pos, n)

Это формирует набор строк из n символов, начиная с позиции индекса, отсчитываемой от нуля, pos другой строки. Следующий код иллюстрирует это:

char str[] = «I love you»;
string strCol = string(str, 2, 4);
cout << strCol << \n;

На выходе получается «любовь».

Для двух вышеупомянутых случаев, если n больше, чем размер строки, генерируется исключение out_of_range — см. Ниже.

string(n, ‘c’)

Образует набор из n символов, где все символы одинаковы. Рассматривать,

string strCol = string(5,‘e’);
cout << strCol << \n;

Результат: «eeeee», 5 e’s.

Назначение строки

После объявления обеих строк строка может быть назначена следующим образом:

string strCol1 = string(«I love you»);
string strCol2;
strCol2 = strCol1;
cout << strCol2 << \n;

Результат: «I love you».

Конструирование с помощью Iterator

Итератор обеспечивает общее представление сканирования через значения коллекции. Синтаксис для создания строки с итератором:

template<class InputIterator>
basic_string(InputIterator begin, InputIterator end, const Allocator&
= Allocator());

Это создает строку для диапазона [начало, конец) — подробности см. Позже.

Уничтожение строки

Чтобы уничтожить строку, просто отпустите ее за пределы области видимости.

Доступ к элементу класса String

Созданный экземпляр строкового объекта может быть индексирован (индексирован) как массив. Подсчет индекса начинается с нуля.

stringName[i]

Операция «stringName [i]» возвращает ссылку на символ (элемент) в i- м индексе коллекции символов. Следующий код выводит v:

string strCol = string(«I love you»);
char ch = strCol[4];
cout << ch << \n;

stringName[i] const

Операция «stringName [i] const» выполняется вместо «stringName [i]», когда строковый объект является константным объектом. Например, он используется в следующем коде:

const string strCol = string(«I love you»);
char ch = strCol[4];
cout << ch << \n;

Выражение возвращает постоянную ссылку на i- й элемент строкового объекта. Ни один из элементов строки не может быть изменен.

Назначение символа с нижним индексом

Непостоянному строковому объекту может быть присвоен символ следующим образом:

string strCol = string(«I call»);
strCol[2] = ‘f’;
cout << strCol << \n;

Результат — «Я падаю». ’c’ был изменен на ’f’.

stringName.at(i)

«StringName.at (i)» похоже на «stringName [i]», но «stringName.at (i)» более надежен. Следующий код показывает, как его следует использовать:

string strCol = string(«I love you»);
char ch = strCol.at(4);
cout << ch << \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 string strCol = string(«I love you»);
char ch = strCol.at(4);
cout << ch << \n;

«At () const» на самом деле является функцией-членом строкового класса.

Присвоение значения с помощью функции at ()

Значение может быть присвоено непостоянному строковому объекту с помощью функции at () следующим образом:

string strCol = string(«I call»);
strCol.at(2) = ‘f’;
cout << strCol << \n;

Результат — «I call».

Проблема с дополнительными сценариями

Проблема с подпрограммами (индексированием) заключается в том, что если индекс выходит за пределы допустимого диапазона, может быть получен неправильный результат или может возникнуть ошибка во время выполнения.

front()

Это возвращает ссылку на первый элемент строкового объекта без удаления элемента. На выходе следующего кода будет «I».

string strCol = string(«I love you»);
char ch = strCol.front();
cout << ch << \n;

Символ не удаляется из строкового объекта.

front() const

Когда конструкции строкового объекта предшествует const, выражение «front () const» выполняется вместо «front ()». Например, он используется в следующем коде.

const string strCol = string(«I love you»);
char ch = strCol.front();
cout << ch << \n;

Возвращается постоянная ссылка. Элемент не удаляется из строкового объекта. Никакой символ не может быть изменен для постоянного строкового объекта.

back()

Это возвращает ссылку на последний элемент строкового объекта без удаления элемента. Результатом следующего кода будет «u».

string strCol = string(«I love you»);
char ch = strCol.back();
cout << ch << \n;

back() const

Когда конструкции строкового объекта предшествует const, выражение «back () const» выполняется вместо «back ()». Например, он используется в следующем коде.

const string strCol = string(«I love you»);
char ch = strCol.back();
cout << ch << \n;

Возвращается постоянная ссылка. Элемент не удаляется из строкового объекта.

Емкость строки

size_type capacity() const noexcept

Эта функция-член емкости возвращает общее количество символов, которое строка может содержать без необходимости перераспределения. Сегмент кода для этого:

string strCol = string();
int num = strCol.capacity();
cout << num << \n;

На моем компьютере выводится 15.

reserve(n)

Объем памяти не всегда доступен в бесплатном магазине. Дополнительное место можно зарезервировать заранее. Рассмотрим следующий фрагмент кода:

string strCol = string(«love»);
strCol.reserve(6);
cout << strCol.capacity() << \n;

На моем компьютере выводится 15.

size() const noexcept

Это возвращает количество символов в строке. Следующий код иллюстрирует:

string strCol = string(«I love you»);
int num = strCol.size();
cout << num << \n;

Результатом будет 10, что не включает символы nul, \ 0.

length() const noexcept

 same as size().
Note: size() <= capacity() ..

shrink_to_fit()

Может уменьшить capacity () до size (), вызвав перераспределение; это не обязательно. Следующий код демонстрирует это:

string strCol = string(«I love you»);
strCol.reserve(12);
strCol.shrink_to_fit();
int sz = strCol.size();
cout << sz << \n;

На выходе будет 10, а не 12 или 16. Функция возвращает void.

resize(sz), resize(sz,’c’)

Это изменяет размер строки. Если новый размер меньше старого, то элементы ближе к концу стираются. Если новый размер больше, то ближе к концу добавляется какой-нибудь символ по умолчанию. Чтобы добавить определенный символ, используйте функцию resize () с двумя аргументами. Следующий фрагмент кода иллюстрирует использование двух функций:

string strCol = string(«I love you»);
strCol.resize(6);
cout << «New size of strCol: « << strCol.size() << \n;
string strCol1 = string(«I love», ‘e’);
strCol1.resize(12);
cout << «New size of strCol1: « << strCol1.size() << \n;

Результат:

New size of strCol: 6
New size of strCol1: 12
The function returns void.

clear() noexcept

Удаляет все элементы из строки, как показано в следующем сегменте кода:

string strCol = string(«I love you»);
strCol.clear();
cout << strCol.size() << \n;

Результатом будет 0. Функция возвращает void.

empty() const noexcept

Это возвращает 1 для истины, если в строковом объекте нет символа, или 0 для ложного, если строковый объект не пуст. Следующий код иллюстрирует это:

string strCol1 = string(«I love you»);
cout << strCol1.empty() << \n;
string strCol2 = string();
cout << strCol2.empty() << \n;

Результат:


1

Возвращение итераторов и класса String

Итератор похож на указатель, но имеет больше функций, чем указатель.

begin() noexcept

Возвращает итератор, который указывает на первый символ (элемент) строкового объекта, как в следующем сегменте кода:

string strCol = string(«I love you»);
basic_string<char>::iterator iter = strCol.begin();
cout << *iter << \n;

На выходе будет «I». Обратите внимание на способ объявления объявления, получающего итератор. Итератор разыменовывается в возвращаемом выражении для получения значения точно так же, как разыменование указателя.

Читайте также:  Какой язык программирования лучше

begin() const noexcept

Возвращает итератор, указывающий на первый элемент коллекции строковых объектов. Когда конструкции объекта предшествует const, выражение «begin () const» выполняется вместо «begin ()». При этом условии соответствующий элемент в объекте не может быть изменен. Например, он используется в следующем коде.

const string strCol = string(«I love you»);
basic_string<char>::const_iterator iter = strCol.begin();
cout << *iter << \n;

На выходе будет «I». Обратите внимание, что на этот раз для получения возвращенного итератора был использован const_iterator вместо простого итератора.

end() noexcept

Возвращает итератор, который указывает сразу за последним элементом строкового объекта. Рассмотрим следующий фрагмент кода:

string strCol = string(«I love you»);
basic_string<char>::iterator iter = strCol.end();
cout << *iter << \n;

Результатом является null, что является ничем, поскольку за последним элементом нет конкретного элемента.

end() const noexcept

Возвращает итератор, который указывает сразу за последним элементом строкового объекта. Когда конструкции строкового объекта предшествует const, выражение «end () const» выполняется вместо «end ()». Рассмотрим следующий фрагмент кода:

const string strCol = string(«I love you»);
basic_string<char>::const_iterator iter = strCol.end();
cout << *iter << \n;

Результат равен нулю. Обратите внимание, что на этот раз для получения возвращенного итератора был использован const_iterator вместо простого итератора.

Обратная итерация

Возможно иметь итератор, который выполняет итерацию от фактического конца до непосредственно перед первым элементом:

rbegin() noexcept

Возвращает итератор, который указывает на последний элемент строкового экземпляра объекта, как в следующем сегменте кода:

string strCol = string(«I love you»);
basic_string<char>::reverse_iterator iter = strCol.rbegin();
cout << *iter << \n;

Результатом будет «u». Обратите внимание на способ объявления объявления, получающего обратный итератор. Итератор разыменовывается в возвращаемом выражении для получения значения точно так же, как разыменование указателя.

rbegin() const noexcept

Возвращает итератор, указывающий на последний элемент строкового объекта. Когда конструкции объекта предшествует const, выражение «rbegin () const» выполняется вместо «rbegin ()». При этом условии соответствующий элемент в объекте не может быть изменен. Эта функция используется, например, в следующем коде.

const string strCol = string(«I love you»);
basic_string<char>::const_reverse_iterator iter = strCol.rbegin();
cout << *iter << \n;

Результатом будет «u». Обратите внимание, что на этот раз был использован const_reverse_iterator вместо просто reverse_iterator для получения возвращенного итератора.

rend() noexcept

Возвращает итератор, который указывает непосредственно перед первым элементом строкового объекта. Рассмотрим следующий фрагмент кода:

string strCol = string(«I love you»);
basic_string<char>::reverse_iterator iter = strCol.rend();
cout << *iter << \n;

Результатом является null, что является ничем, поскольку непосредственно перед первым элементом нет конкретного элемента.

rend() const noexcept

Возвращает итератор, который указывает непосредственно перед первым элементом строкового объекта. Когда конструкции объекта предшествует const, выражение «rend () const» выполняется вместо «rend ()». Рассмотрим следующий фрагмент кода:

const string strCol = string(«I love you»);
basic_string<char>::const_reverse_iterator iter = strCol.rend();
cout << *iter << \n;

Результат равен нулю. Обратите внимание, что на этот раз был использован const_reverse_iterator вместо просто reverse_iterator для получения возвращенного итератора.

Строковые модификаторы

Модификатор, изменяющий строковый объект, также может принимать или возвращать итератор.

Appending

basic_string& operator+=(const basic_string& str)

Добавляет правый строковый объект к левому строковому объекту. Пример:

string strCol1 = string(«I love»);
string strCol2 = string(» you»);
strCol1 += strCol2;
cout << strCol1 << \n;

Результат: “I love you”. Do not forget that “strCol1 += strCol2” is same as “strCol1 = strCol1+strCol2”.

basic_string& operator+=(const charT* s)

Добавляет строковый литерал к коллекции строковых объектов. Пример:

string strCol = string(«I love»);
strCol += » you»;
cout << strCol << \n;

Вывод: «I love you».

basic_string& operator+=(charT c)

Добавляет один символ в строку объекта. Пример:

string strCol = string(«I love yo»);
strCol += ‘u’;
cout << strCol << \n;

Вывод: «I love y».

basic_string& operator+=(initializer_list<charT>)

Добавляет список инициализаторов. Пример:

string strCol = string(«I love»);
strCol += {‘ ‘,‘y’,‘o’,‘u’,\0};
cout << strCol << \n;

Вывод: «I love». Всегда полезно добавлять nul, \ 0 в конец списка инициализаторов символов.

basic_string& append(const basic_string& str)

Добавляет объект строки аргумента к основному объекту строки. Пример:

string strCol1 = string(«I love»);
string strCol2 = string(» you»);
strCol1.append(strCol2);
cout << strCol1 << \n;

Вывод: «I love you».

basic_string& append(const charT* s)

Добавляет аргумент строкового литерала к основной строке. Пример

string strCol = string(«I love»);
strCol = strCol.append(» you»);
cout << strCol << \n;

Вывод: «I love you».

basic_string& append(initializer_list<charT>)

Добавляет список инициализаторов, который является аргументом, к основной строке. Пример:

string strCol = string(«I love»);
strCol = strCol.append({‘ ‘,‘y’,‘o’,‘u’,\0});
cout << strCol << \n;

Вывод: «I love you». Всегда полезно добавлять символы nul, \ 0 в конец списка инициализаторов.

basic_string& append(size_type n, charT c)

Добавляет n одинаковых символов. Пример:

string strCol = string(«tab»);
strCol = strCol.append(2, ‘o’);
cout << strCol << \n;

Вывод: «taboo».

basic_string& append(const charT* s, size_type n)

Добавляет первые n элементов строкового литерала к основному строковому объекту. Пример:

string strCol = string(«I love»);
strCol = strCol.append(» you so», 4);
cout << strCol << \n;

Результат: «I love you». Если n больше длины литерала, генерируется исключение length_error.

basic_string& append(const basic_string& str, size_type pos, size_type n = npos)

Добавляет n символов из индекса pos в основную строку. Пример:

string strCol = string(«I love»);
strCol = strCol.append(«ve you so», 2, 4);
cout << strCol << \n;

Вывод: «I love you». Здесь также будет сгенерировано исключение, см. Позже.

Назначение

basic_string& assign(const basic_string& str)

Назначает объект строки аргумента основной строке, заменяя любое содержимое, которое там было.

string strCol1 = string(«I love you»);
string strCol2 = string(«She needs me»);
strCol1 = strCol1.assign(strCol2);
cout << strCol1 << \n;

Вывод: «She needs me».

basic_string& assign(const charT* s)

Назначает аргумент строкового литерала основной строке, заменяя любое содержимое, которое там было.

string strCol = string(«I love you»);
strCol = strCol.assign(«She needs me»);
cout << strCol << \n;

Вывод: «She needs me».

basic_string& assign(initializer_list<charT>)

Assigns an initializer list argument to the main string, replacing any content that was there.
[cc lang=«c» escaped=«true» width=«780»]
string strCol = string(«I love you»);
strCol = strCol.assign({‘S’,‘h’,‘e’,‘ ‘,‘n’,‘e’,‘e’,‘d’,‘s’,‘ ‘,‘m’,‘e’,\0});
cout << strCol << \n;

Вывод: «She needs me». Хорошо всегда добавлять nul, \ 0 в конец списка символов, чтобы сформировать строковый литерал.

basic_string& assign(const charT* s, size_type n)

Назначает первые n символов аргумента строкового литерала основной строке, заменяя любое содержимое, которое там было.

string strCol = string(«I love you»);
strCol = strCol.assign(«She needs me», 9);
cout << strCol << \n;

Выход: «She needs».

basic_string& assign(size_type n, charT c)

Назначает аргумент из n одинаковых символов основной строке, заменяя любое содержимое, которое там было.

string strCol = string(«I love you»);
strCol = strCol.assign(4, ‘e’);
cout << strCol << \n;

Выход: eeee

basic_string& assign(const basic_string& str, size_type pos,
size_type n = npos)

Назначает n символов аргумента строкового объекта, начиная с pos, основной строке, заменяя любое содержимое, которое там было.

string strCol = string(«I love you»);
strCol = strCol.assign(«She needs me», 4, 5);
cout << strCol << \n;

Вывод: «needs». Выдает исключение — см. Позже.

Inserting

basic_string& insert(size_type pos, const basic_string& str)

Вставляет аргумент строкового объекта в основную строку по индексу pos.

string strCol1 = string(«I love you»);
string strCol2 = string(«hate and «);
strCol1 = strCol1.insert(2, strCol2);
cout << strCol1 << \n;

Вывод: «I hate and love you». Выдает исключение — см. Позже.

basic_string& insert(size_type pos1, const basic_string&
str,size_type pos2, size_type n = npos)

Вставляет длину n символов из pos2 аргумента строкового объекта в основную строку по индексу pos1.

string strCol1 = string(«I love you»);
string strCol2 = string(«hate, want and need»);
strCol1 = strCol1.insert(2, strCol2, 6, 9);
cout << strCol1 << \n;

Вывод: «I want and love you».

iterator insert(const_iterator p, charT c)

Вставляет определенный символ, который является аргументом, в позицию, на которую указывает итератор. Возвращает итератор для позиции вновь вставленного символа.

string strCol = string(«I love you»);
basic_string<char>::iterator iter = strCol.begin();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<char>::iterator retI = strCol.insert(iter, ‘d’);
cout << *retI << \n;
cout << strCol << \n;

Результат:

‘d’

“I loved you”

iterator insert(const_iterator p, size_type n, charT c)

Вставляет n того же символа аргумента в позицию, на которую указывает итератор. Возвращает итератор для позиции начала вновь вставленных одинаковых символов.

string strCol = string(«Tab in the land.»);
basic_string<char>::iterator iter = strCol.begin();
++iter; ++iter; ++iter;
basic_string<char>::iterator retI = strCol.insert(iter, 2, ‘o’);
cout << *retI << \n;
cout << strCol << \n;

Результат:

‘o’

“Taboo in the land.”

basic_string& insert(size_type pos, const charT* s)

Вставляет строковый литерал аргумента в индекс, pos в основную строку.

string strCol = string(«Tab in the land.»);
strCol = strCol.insert(3, «oo»);
cout << strCol << \n;

Результат: «Taboo in the land».

basic_string& insert(size_type pos, const charT* s, size_type n)

Вставляет первые n символов строкового литерала аргумента в индекс pos в основной строке.

string strCol = string(«Tab in the land.»);
strCol = strCol.insert(3, «oooo», 2);
cout << strCol << \n;

Результат: «Taboo in the land».

Читайте также:  Flarum: добавление адреса Web3 в профиль пользователя

Replacing

basic_string& replace(size_type pos1, size_type n1, const basic_string& str))

Заменяет n1 символов в основном строковом объекте из индекса pos1 на строковый объект аргумента.

string strCol1 = string(«I love you»);
string strCol2 = string(«hate you and»);
strCol1 = strCol1.replace(2, 4, strCol2);
cout << strCol1 << \n;

Вывод: «I hate you and you». Выдает исключение — см. Позже.

basic_string& replace(size_type pos1, size_type n1, const basic_string&
str,size_type pos2, size_type n2 = npos)

Заменяет n1 символов в основном строковом объекте из индекса pos1 на n2 символов строкового объекта аргумента из индекса pos2.

string strCol1 = string(«I love you»);
string strCol2 = string(«we hate him and her»);
strCol1 = strCol1.replace(2, 4, strCol2, 3, 12);
cout << strCol1 << \n;

Вывод: «I hate him and you».

basic_string& replace(size_type pos1, size_type n1, const charT* s,
size_type n2)

Заменяет n1 символов в основном строковом объекте из индекса pos1 первыми n2 символами литерального строкового аргумента.

string strCol1 = string(«I love you»);
strCol1 = strCol1.replace(2, 4, «hate him and her», 12);
cout << strCol1 << \n;

Вывод: «I hate him and you».

basic_string& replace(size_type pos, size_type n, const charT* s)

Заменяет n символов в основном строковом объекте из индекса pos на буквальный строковый аргумент.

string strCol1 = string(«I love you»);
strCol1 = strCol1.replace(2, 4, «hate him and»);
cout << strCol1 << \n;

Вывод: «I hate him and you».

basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c)

Заменяет n1 символов в главном строковом объекте из индекса pos1 на n2 того же символа аргумента.

string strCol1 = string(«A bad tablet there.»);
strCol1 = strCol1.replace(9, 3, 2, ‘o’);
cout << strCol1 << \n;

Вывод: «A bad taboo there».

iterator erase(const_iterator p)

Удаляет символ в позиции, на которую указывает итератор; затем возвращает позицию итератора, которая теперь занята символом, который был рядом с этим символом (или end ()). Следующий код иллюстрирует это:

string strCol = string(«abcd»);
basic_string<char>::iterator iter = strCol.begin();
++iter; ++iter;
strCol.erase(iter);
cout << strCol[] << ‘ ‘ << strCol[1] << 
 << strCol[2]<< \n;

Выход: abd

basic_string& erase(size_type pos = , size_type n = npos)

Удаляет n символов из индекса поз.

string strCol = string(«abcd»);
strCol.erase(1, 2);
cout << strCol[] << ‘ ‘ << strCol[1] << \n;

Выход: a d

void push_back(charT c)

Чтобы добавить один символ в конец строки:

string strCol = string(«abcd»);
strCol.push_back(‘5’);
cout << strCol << \n;

Выход: abcd5

void pop_back()

Удаляет последний символ, не возвращая его. Размер строки уменьшается на 1.

string strCol = string(«abcde»);
strCol.pop_back();
cout << strCol << \n;

Выход: abcd

void swap(basic_string& s)

Литералы двух строковых объектов можно поменять местами.

string strCol1 = string(<a id=«post-69618-__DdeLink__781_3724385525»></a>«abcde»);
string strCol2 = string(«1234567»);
strCol1.swap(strCol2);
cout << strCol1 << \n;
cout << strCol2 << \n;

Результат:

«1234567»
«abcde»

String Operations

const charT* c_str() const noexcept

Возвращает указатель на первый элемент строки. Указатель можно увеличивать.

const string strCol = string(«abcde»);
const char* p = strCol.c_str();
cout << *<< \n;
++p;
cout << *<< \n;

Выход:

а
б

Из-за второй константы в заголовке программа не может изменить какой-либо символ в строке. Конструкции предшествует const.

const charT* data() const noexcept

Возвращает указатель на первый элемент строки. Указатель можно увеличивать.

const string strCol = string(«abcde»);
const char* p = strCol.data();
cout << *<< \n;
++p;
cout << *<< \n;

Выход:

а
б

Из-за второй константы в заголовке программа не может изменить какой-либо символ в строке. Конструкции предшествует const.

basic_string substr(size_type pos = 0, size_type n = npos) const

Возвращает строковый объект из n символов для подстроки, начинающейся с индекса pos.

const string strCol = string(«abcdefghij»);
const string retStr = strCol.substr(2, 4);
cout << retStr << \n;

Вывод: cdef

find() Member Functions

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

Ищет объект подстроки, начиная с индекса поз. Если найдено, возвращает начало подстроки в основной строке.

string strCol = string(«We are the world!»);
string strCol1 = string(«the»);
int num = strCol.find(strCol1, 2);
cout << num << \n;

Выход:

index: 7
Returns -1, when not found.

size_type find(const charT* s, size_type pos = 0) const

Ищет литерал подстроки, начинающийся с индекса поз. Если найдено, возвращает начало подстроки в основной строке.

string strCol = string(«We are the world!»);
int num = strCol.find(«are», );
cout << num << \n;

Поскольку «pos = 0» является значением по умолчанию, 0 в аргументе можно было опустить.

Выход: 3

Если не найдено, возвращает −1.

size_type find (const charT* s, size_type pos, size_type n) const

Ищет первые n символов литерала подстроки, начиная с индекса поз. Если найдено, возвращает начало подстроки в основной строке.

string strCol = string(«The biggest boy»);
int num = strCol.find(«bigger», 1, 3);
cout << num << \n;

Выход: 4

Если не найдено, возвращает −1.

size_type find(charT c, size_type pos = 0) const

Ищет символ c, начиная с индекса поз. Если найдено, возвращает начало подстроки в основной строке. Если не найден, возвращает −1.

string strCol = string(«We are the world!»);
int num = strCol.find(‘z’);
cout << num << \n;

Выход: −1

Существуют следующие обратные функции-члены find ():

size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
size_type rfind(const charT* s, size_type pos = npos) const;
size_type rfind(const charT* s, size_type pos, size_type n) const;
size_type rfind(charT c, size_type pos = npos) const;

Comparison Member Functions

int compare(const basic_string& str) const noexcept

Сравнивает строковый объект аргумента с основным строковым объектом. Если основная строка встречается перед аргументом (в словаре), она возвращает положительное число. Если это происходит после основной строки, возвращается отрицательное число. Если две строки совпадают, возвращается ноль.

string strCol1 = string(«crowd»);
string strCol2 = string(«people»);
int num = strCol1.compare(strCol2);
cout << num << \n;

Выход: −13

int compare(const charT* s) const

То же, что и выше, но аргумент является строковым литералом.

string strCol1 = string(«people»);
int num = strCol1.compare(«people»);
cout << num << \n;

Выход: 0

String Operators

Эти операторы применимы к строковым объектам и не обязательно к строковым литералам.

+

Объединяет два строковых объекта и возвращает объединение.

string strCol1 = string(«dancing on»);
string strCol2 = string(» the moon»);
string strCol = strCol1+strCol2;
cout << strCol << \n;

Результат: «dancing on the moon».

==

Возвращает 1 для истины, если строковые объекты совпадают; и ноль для false, если это не так.

string strCol1 = string(«dancing on»);
string strCol2 = string(» on the moon»);
bool bl = strCol1 == strCol2;
cout << bl << \n;

Выход: 0

!=

Возвращает 1, если строковые объекты не совпадают, и ноль, если они совпадают.

string strCol1 = string(«dancing on»);
string strCol2 = string(» on the moon»);
bool bl = strCol1 != strCol2;
cout << bl << \n;

Выход: 1

<

Возвращает 1, если левый операнд меньше правого операнда согласно словарю, или ноль, если это не так.

string strCol1 = string(«dancing on»);
string strCol2 = string(» on the moon»);
bool bl = strCol1 < strCol2;
cout << bl << \n;

Выход: 0

Для обычных символов в C ++ в возрастающем порядке числа идут перед прописными буквами, которые идут перед строчными буквами. Пробел стоит перед нулем и всеми ними.

Типы символов основной строки C ++

char

Тип char является исходным типом C ++ и обычно хранит символ в 8 битах.

char16_t

Это сохраняет символ в 16 битах.

char32_t

Это сохраняет символ в 32 бита.

wchar_t

char16_t и char32_t — широкие символы. wchar_t — это расширенный символ, который является проприетарным и определяется реализацией.

Эти типы называются чертами характера. Однако C ++ технически относится к ним как к специализации черт. В этой статье основное внимание уделяется типу char. Подход к другим типам немного другой — см. Позже.

Other String Operation Member Functions

Сигнатуры других функций строковых операций:

size_type find_first_of(const basic_string& str, size_type pos = ) const noexcept;
size_type find_first_of(const charT* s, size_type pos, size_type n) const;
size_type find_first_of(const charT* s, size_type pos = ) const;
size_type find_first_of(charT c, size_type pos = ) const;
size_type find_last_of (const basic_string& str, size_type pos = npos) const noexcept;
size_type find_last_of (const charT* s, size_type pos, size_type n) const;
size_type find_last_of (const charT* s, size_type pos = npos) const;
size_type find_last_of (charT c, size_type pos = npos) const;
size_type find_first_not_of(const basic_string& str, size_type pos = ) const noexcept;
size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
size_type find_first_not_of(const charT* s, size_type pos = ) const;
size_type find_first_not_of(charT c, size_type pos = ) const;
size_type find_last_not_of (const basic_string& str, size_type pos = npos) const noexcept;
size_type find_last_not_of (const charT* s, size_type pos, size_type n) const;
size_type find_last_not_of (const charT* s, size_type pos = npos) const;
size_type find_last_not_of (charT c, size_type pos = npos) const;

Заключение

В C ++ есть строковые литералы и строковые объекты. Строковый объект имеет набор последовательных символов, аналогичный последовательному массиву символов. Разница между коллекцией строк и массивом состоит в том, что коллекция строк может увеличиваться или уменьшаться в длину. Строковый объект создается (создается) из строкового класса. Строковый объект — это структура данных с функциями-членами. Функции-члены можно классифицировать по заголовкам построения объекта, доступа к элементам, емкости строки, функций-членов строки с аргументами итератора и возвращаемыми типами, а также модификаторами строки. Также существуют строковые операторы равенства и отношения.

Оцените статью
bestprogrammer.ru
Добавить комментарий