Сколько байт занимает string в c

Каждая переменная имеет определенный тип. И этот тип определяет, какие значения может иметь переменная, какие операции с ней можно производить и сколько байт в памяти она будет занимать. В языке C++ определены следующие базовые типы данных: логический тип bool , целочисленные типы, типа чисел с плавающей точкой, символьные типы. Рассмотрим эти группы по отдельности.

Логический тип

Логический тип bool может хранить одно из двух значений: true (истинно, верно) и false (неверно, ложно). Например, определим пару переменных данного типа и выведем их значения на консоль:

#include int main() < bool isAlive ; bool isDead ; std::cout

При выводе значения типа bool преобразуются в 1 (если true) и 0 (если false). Как правило, данный тип применяется преимущество в условных выражениях, которые будут далее рассмотрены.

Значение по умолчанию для переменных этого типа — false .

Целочисленные типы

Целые числа в языке C++ представлены следующими типами:

signed char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от -128 до 127
unsigned char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от 0 до 255
char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255 Несмотря на то, что данный тип представляет тот же диапазон значений, что и вышеописанный тип signed char , но они не эквивалентны. Тип char предназначен для хранения числового кода символа и в реальности может представлять как signed byte , так и unsigned byte в зависимости от конкретного компилятора.
short : представляет целое число в диапазоне от –32768 до 32767. Занимает в памяти 2 байта (16 бит). Данный тип также имеет псевдонимы short int , signed short int , signed short .
unsigned short : представляет целое число в диапазоне от 0 до 65535. Занимает в памяти 2 байта (16 бит). Данный тип также имеет синоним unsigned short int .
int : представляет целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита). Диапазон предельных значений соответственно также может варьироваться от –32768 до 32767 (при 2 байтах) или от −2 147 483 648 до 2 147 483 647 (при 4 байтах). Но в любом случае размер должен быть больше или равен размеру типа short и меньше или равен размеру типа long Данный тип имеет псевдонимы signed int и signed .
unsigned int : представляет положительное целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита), и из-за этого диапазон предельных значений может меняться: от 0 до 65535 (для 2 байт), либо от 0 до 4 294 967 295 (для 4 байт). Имеет псевдоним unsigned
long : в зависимости от архитектуры может занимать 4 или 8 байт и представляет целое число в диапазоне от −2 147 483 648 до 2 147 483 647 (при 4 байтах) или от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807 (при 8 байтах). Занимает в памяти 4 байта (32 бита) или. Имеет псевдонимы long int , signed long int и signed long
unsigned long : представляет целое число в диапазоне от 0 до 4 294 967 295. Занимает в памяти 4 байта (32 бита). Имеет синоним unsigned long int .
long long : представляет целое число в диапазоне от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807. Занимает в памяти 8 байт (64 бита). Имеет псевдонимы long long int , signed long long int и signed long long .
unsigned long long : представляет целое число в диапазоне от 0 до 18 446 744 073 709 551 615. Занимает в памяти, как правило, 8 байт (64 бита). Имеет псевдоним unsigned long long int .

Для представления чисел в С++ применятся целочисленные литералы со знаком или без, типа -10 или 10. Например, определим ряд переменных целочисленных типов и выведем их значения на консоль:

#include int main() < signed char num1< -64 >; unsigned char num2< 64 >; short num3< -88 >; unsigned short num4< 88 >; int num5< -1024 >; unsigned int num6< 1024 >; long num7< -2048 >; unsigned long num8< 2048 >; long long num9< -4096 >; unsigned long long num10< 4096 >; std::cout u или U. Литералы типов long и long long имеют суффиксы L/l и LL/ll соответственно:

#include int main() < unsigned int num6< 1024U >; // U - unsigned int long num7< -2048L >; // L - long unsigned long num8< 2048UL >; // UL - unsigned long long long num9< -4096LL >; // LL - long long unsigned long long num10< 4096ULL >;// ULL - unsigned long long std::cout #include int main() < int num< 1'234'567'890 >; std::cout

Различные системы исчисления

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

Чтобы указать, что число - шестнадцатеричное, перед числом указывается префикс 0x или 0X . Например:

int num1< 0x1A>; // 26 - в десятичной int num2< 0xFF >; // 255 - в десятичной int num3< 0xFFFFFF >; //16777215 - в десятичной

Чтобы указать, что число - восьмеричное, перед числом указывается ноль 0 . Например:

int num1< 034>; // 26 - в десятичной int num2< 0377 >; // 255 - в десятичной

Бинарные литералы предваряются префиксом 0b или 0B :

int num1< 0b11010>; // 26 - в десятичной int num2< 0b11111111 >; // 255 - в десятичной

Все эти типы литералов также поддерживают суффиксы U/L/LL :

unsigned int num1< 0b11010U>; // 26 - в десятичной long num2< 0377L >; // 255 - в десятичной unsigned long num3< 0xFFFFFFULL >; //16777215 - в десятичной

Числа с плавающей точкой

Для хранения дробных чисел в C++ применяются числа с плавающей точкой. Число с плавающей точкой состоит из двух частей: мантиссы и показателя степени . Оба могут быть как положительными, так и отрицательными. Величина числа – это мантисса, умноженная на десять в степени экспоненты.

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

3.650000E02

В качестве разделителя целой и дробной частей используется символ точки. Мантисса здесь имеет семь десятичных цифр - 3.650000 , показатель степени - две цифры 02 . Буква E означает экспоненту, после нее указывается показатель степени (степени десяти), на которую умножается часть 3.650000 (мантисса), чтобы получить требуемое значение. То есть, чтобы вернуться к обычному десятичному представлению, нужно выполнить следующую операцию:

3.650000 × 10² = 365

Другой пример - возьмем небольшое число:

-3.650000E-03

В данном случае мы имеем дело с числом –3.65 × 10 -3 , что равно –0.00365 . Здесь мы видим, что в зависимости от значения показателя степени десятичная точка "плавает". Собственно поэтому их и называют числами с плавающей точкой.

Однако хотя такая запись позволяет определить очень большой диапазон чисел, не все эти числа могут быть представлены с полной точностью; числа с плавающей запятой в целом являются приблизительными представления точного числа. Например, число 1254311179 выглядело бы так: 1.254311E09 . Однако если перейти к десятичной записи, то это будет 1254311000 . А это не то же самое, что и 1254311179 , поскольку мы потеряли три младших разряда.

В языке C++ есть три типа для представления чисел с плавающей точкой:

float : представляет вещественное число одинарной точности с плавающей точкой в диапазоне +/- 3.4E-38 до 3.4E+38. В памяти занимает 4 байта (32 бита)
double : представляет вещественное число двойной точности с плавающей точкой в диапазоне +/- 1.7E-308 до 1.7E+308. В памяти занимает 8 байт (64 бита)
long double : представляет вещественное число двойной точности с плавающей точкой не менее 8 байт (64 бит). В зависимости от размера занимаемой памяти может отличаться диапазон допустимых значений.

В своем внутреннем бинарном представлении каждое число с плавающей запятой состоит из одного бита знака, за которым следует фиксированное количество битов для показателя степени и набор битов для хранения мантиссы. В числах float 1 бит предназначен для хранения знака, 8 бит для экспоненты и 23 для мантиссы, что в сумме дает 32 бита. Мантисса позволяет определить точность числа в виде 7 десятичных знаков.

В числах double : 1 знаковый бит, 11 бит для экспоненты и 52 бит для мантиссы, то есть в сумме 64 бита. 52-разрядная мантисса позволяет определить точность до 16 десятичных знаков.

Для типа long double расклад зависит от конкретного компилятора и реализации этого типа данных. Большинство компиляторов предоставляют точность до 18 - 19 десятичных знаков (64-битная мантисса), в других же (как например, в Microsoft Visual C++) long double аналогичен типу double .

В C++ литералы чисел с плавающими точками представлены дробными числами, которые в качестве разделителя целой и дробной частей применяют точку:

double num ;

Даже если переменной присваивается целое число, чтобы показать, что мы присваиваем число с плавающей точкой, применяется точка:

double num1< 1 >; // 1 - целочисленный литерал double num2< 1. >; //1. - литерал числа с плавающей точкой

Так, здесь число 1. представляет литерал числа с плавающей точкой, и в принципе аналогичен 1.0 .

По умолчанию все такие числа с точкой расцениваются как числа типа double. Чтобы показать, что число представляет другой тип, для float применяется суффикс f / F , а для long double - l / L :

float num1< 10.56f >; // float long double num2< 10.56l >; // long double

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

double num1< 5E3 >; // 5E3 = 5000.0 double num2< 2.5e-3 >; // 2.5e-3 = 0.0025

Размеры типов данных

При перечислении типов данных указывался размер, который он занимает в памяти. Но стандарт языка устанавливает лишь минимальные значения, которые должны быть. Например, для типов int и short минимальное значение - 16 бит, для типа long - 32 бита, для типа long double - 64 разряда. При этом размер типа long должен быть не меньше размера типа int, а размер типа int - не меньше размера типа short, а размер типа long double должен быть не меньше double . А разработчики компиляторов могут выбирать предельные размеры для типов самостоятельно, исходя из аппаратных возможностей компьютера.

К примеру, компилятор g++ Windows для long double использует 16 байт. А компилятор в Visual Studio, который также работает под Windows, и clang++ под Windows для long double используют 8 байт. То есть даже в рамках одной платформы разные компиляторы могут по разному подходить к размерам некоторых типов данных. Но в целом используются те размеры, которые указаны выше при описании типов данных.

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

#include int main() < long double number ; std::cout

sizeof(number) = 16

Символьные типы

В C++ есть следующие символьные типы данных:

char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255
wchar_t : представляет расширенный символ. На Windows занимает в памяти 2 байта (16 бит), на Linux - 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 65 535 (при 2 байтах), либо от 0 до 4 294 967 295 (для 4 байт)
char8_t : представляет один символ в кодировке Unicode. Занимает в памяти 1 байт. Может хранить любой значение из диапазона от 0 до 256
char16_t : представляет один символ в кодировке Unicode. Занимает в памяти 2 байта (16 бит). Может хранить любой значение из диапазона от 0 до 65 535
char32_t : представляет один символ в кодировке Unicode. Занимает в памяти 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 4 294 967 295

char

Переменная типа char хранит числовой код одного символа и занимает один байт. Стандарт языка С++ не определяет кодировку символов, которая будет использоваться для символов char, поэтому производители компиляторов могут выбирать любую кодировку, но обычно это ASCII.

В качестве значения переменная типа char может принимать один символ в одинарных кавычках, либо числовой код символа:

#include int main() < char a1 ; char a2 ; std::cout

В данном случае переменные a1 и a2 будут иметь одно и то же значение, так как 65 - это числовой код символа "A" в таблице ASCII. При выводе на консоль с помощью cout по умолчанию отображается символ.

Кроме того, в C++ можно использовать специальные управляющие последовательности, которые предваряются слешем и которые интерпретируются особым образом. Например, "\n" представляет перевод строки, а "\t" - табуляцию.

Однако ASCII обычно подходит для наборов символов языков, которые используют латиницу. Но если необходимо работать с символами для нескольких языков одновременно или с символами языков, отличных от английского, 256-символьных кодов может быть недостаточно. И в этом случае применяется Unicode .

Unicode (Юникод) — это стандарт, который определяет набор символов и их кодовых точек, а также несколько различных кодировок для этих кодовых точек. Наиболее часто используемые кодировки: UTF-8, UTF-16 и UTF-32. Разница между ними заключается в том, как представлена кодовая точка символа; числовое же значение кода для любого символа остается одним и тем же в любой из кодировок. Основные отличия:

UTF-8 представляет символ как последовательность переменной длины от одного до четырех байт. Набор символов ASCII появляется в UTF-8 как однобайтовые коды, которые имеют те же значения кодов, что и в ASCII. UTF-8 на сегодняшний день является самой популярной кодировкой Unicode.
UTF-16 представляет символы как одно или два 16-битных значения.
UTF-32 представляет все символы как 32-битные значения

В C++ есть четыре типа для хранения символов Unicode: wchar_t , char8_t , char16_t и char32_t ( char16_t и char32_t были добавлены в C+11, а char8_t - в C++20).

wchar_t

Тип wchar_t — это основной тип, предназначенный для наборов символов, размер которых выходит за пределы одного байта. Собственно отсюда и его название: wchar_t - wide (широкий) char. происходит от широкого символа, потому что этот символ «шире», чем обычный однобайтовый символ. Значения wchar_t определяются также как и символы char за тем исключением, что они предваряются символов "L":

wchar_t a1 ;

Также можно передать код символа

wchar_t a1 ;

Значение, заключенное в одинарные кавычки, представляет собой шестнадцатеричный код символа. Обратная косая черта указывает на начало управляющей последовательности, а x после обратной косой черты означает, что код шестнадцатеричный.

Стоит учитывать, что для вывода на консоль символов wchar_t следует использовать не std::cout , а поток std::wcout :

#include int main() < char h = 'H'; wchar_t i ; std::wcout

При этом поток std::wcout может работать как с char, так и с wchar_t. А поток std::cout для переменной wchar_t вместо символа будет выводить его числовой код.

Проблема с типом wchar_t заключается в том, что его размер сильно зависит от реализации и применяемой кодировки. Кодировка обычно соответствует предпочтительной кодировке целевой платформы. Так, для Windows wchar_t обычно имеет ширину 16 бит и кодируется с помощью UTF-16. Большинство других платформ устанавливают размер в 32 бита, а в качестве кодировки применяют UTF-32. С одной стороны, это позволяет больше соответствовать конкретной платформе. Но с другой стороны, затрудняет написание кода, переносимого на разные платформы. Поэтому в общем случае часто рекомендуется использовать типы char8_t , char16_t и char32_t . Значения этих типов предназначены для хранения символов в кодировке UTF-8, UTF-16 или UTF-32 соответственно, а их размеры одинаковы на всех распространенных платформах.

Для определения символов типов char8_t , char16_t и char32_t применяются соответственно префиксы u8, u и U:

char8_t c< u8'l' >; char16_t d< u'l' >; char32_t e< U'o' >;

Стоит отметить, что для вывода на консоль значений char8_t/char16_t/char32_t пока нет встроенных инструментов типа std:cout/std:wcout .

Спецификатор auto

Иногда бывает трудно определить тип выражения. В этом случае можно предоставить компилятору самому выводить тип объекта. И для этого применяется спецификатор auto . При этом если мы определяем переменную со спецификатором auto, эта переменная должна быть обязательно инициализирована каким-либо значением:

auto number = 5; // number имеет тип int auto sum ; // sum имеет тип double auto distance ; // distance имеет тип unsigned long

На основании присвоенного значения компилятор выведет тип переменной. Неинициализированные переменные со спецификатором auto не допускаются:

string в C++: строки простыми словами

В стандартной библиотеке C++ std::string является ключевым классом для работы со строками. Этот класс предоставляет разработчикам удобный способ управления и манипуляции строками, заменяя традиционные массивы символов. В этой статье мы рассмотрим основные аспекты std::string и его возможности в C++.

Что такое строки (string) в C++

Иллюстрация строк в C++

string - это более удобная альтернатива строками в стиле C, которую можно использовать в C++. Внутреннее устройство string похоже на вектор символов, мы можем изменять строку и ее размер на лету.

Давайте рассмотрим простой пример работы со строками в C++:

#include using namespace std; int main()  string greeting = "Привет"; // инициализация строки string world("Мир"); // явный вызов конструктора string exclamation'!'>; // инициализация как массива символов cout   <" "    ; return 0; >

Вывод данной программы:

Привет Мир!

Теперь давайте разберем, что делает данная программа:

в строке 6 мы присваиваем значение переменной типа string при помощи оператора = . Этот вариант вы будете встречать наиболее часто.
в строке 7 мы явно вызываем конструктор string и передаем туда нужную нам строку.
в строке 8 мы используем тот факт, что строка работает как вектор символов, поэтому мы можем использовать конструкцию вида , , . > .
в строке 10 мы выводим строки на экран используя стандартный cout .

Теперь давайте рассмотрим операции, которые мы можем производить над строками.

Объединение строк (конкатенация)

Чтобы соединить две строки достаточно воспользоваться оператором + :

string c = "С"; string pp = "++"; string cpp = c + pp; cout  "cpp token operator"> cpp  endl;

cpp = C++

При этом не обязательно соединять значения из нескольких переменных. Мы можем объединить строку с C строкой "строка в формате C" (массивом символов char[] ):

string c = "С"; string cpp = c + "++"; cout  "cpp token operator"> cpp  endl;

Нельзя соединить два строковых литерала "C" + "++" , поскольку оператор + не определен на массивах типа char[] . Для того чтобы сложить две строки при помощи + , обязательно на одной из сторон оператора + должна находиться строка string .

Вывод программы идентичен предыдущему:

cpp = C++

Помимо оператора + , есть метод append , который позволяет добавить одну строку к другой:

string lang = "С"; lang.append("++"); cout  "lang token operator"> lang  endl;

lang = C++

Отличие метода append от + заключается в том, что append меняет существующую строку, в то время как + создает новую.

Поскольку append меняет существующую строку, он работает быстрее чем + особенно при многократных слияниях строк.

Стоит отметить, что нельзя получить сумму чисел внутри строки при помощи оператора + . Давайте рассмотрим пример:

string a = "12"; string b = "34"; cout  "a + b token operator"> a + b  endl;

a + b = 1234

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

string a = "12"; cout  a + 34  endl; // Invalid operands to binary expression ('std::string' and 'int')

Что будет выведено на экран:

string a = "23"; string b = "45"; cout  a + b  endl;

Когда две строки конкатенируются с использованием оператора + , их содержимое просто объединяется. Таким образом, "23" + "45" дает "2345" , а не математическую сумму чисел.

Получение длины строки

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

string s = "C++"; cout  "s.length() token operator"> s.length()  endl;

s.length() = 3

У метода length есть “брат-близнец” - size :

string s = "C++"; cout  "s.size() token operator"> s.size()  endl;

s.size() = 3

Между ними нет разницы, поэтому вы можете выбрать название метода на свой вкус.

Получение и изменение символа в строке

string позволяет нам получать любой символ по указанному индексу при помощи оператора [] . При этом можно также использовать метод at , однако оператор [] является более компактным и встречается чаще в реальных программах:

string s = "ABCDE"; cout  "s[1] token operator"> s[1]  endl;

Первый символ в строке имеет индекс 0 .

s[1] = B

Так же, как и с массивами, мы можем присвоить любой ячейке новое значение:

string s = "ABCDE"; s[1] = 'X'; cout  "s[1] token operator"> s[1]  endl;

s[1] = X

Изменение символа в строке

А как же нам объявить строку, которая состоит из двух линий? Для этого достаточно воспользоваться специальным символом \n :

string s = "Первая строка.\nВторая строка"; cout  s  endl;

Первая строка. Вторая строка

В C++ все специальные символы в строках начинаются с \ . Вот примеры часто используемых специальных символов:

\n - перенос строки
\' - одинарная кавычка
\" - двойная кавычка
\\ - обратный слеш

Что будет выведено на экран:

cout  "Привет, мир\\nПривет снова!"  endl;

Привет, мир
Привет снова!
Привет, мир Привет снова!
Привет, мир\nПривет снова!
Привет, мир\nПривет\nснова!

В C++ все специальные символы в строках начинаются с \ . \\ используется для вывода обратного слеша. Поэтому вывод будет “Привет, мир\nПривет снова!” без перехода на новую строку.

Ввод строк из консоли используя cin

cin позволяет нам вводить строки напрямую из консоли. Для этого достаточно указать переменную типа string в которую будет записана строка введенная пользователем:

string name; cout  "Введите ваше имя: "; cin >> name; cout  "Ваше имя: "  name  endl;

Пример работы программы:

Введите ваше имя: Дима Ваше имя: Дима

Однако, если мы попытаемся ввести строку с пробелом, то cin считает строку только до первого пробела. Если мы хотим считать строку полностью, нужно использовать функцию getline :

string name; cout  "Введите ваше имя: "; getline(cin, name); cout  "Ваше имя: "  name  endl;

Пример работы программы:

Введите ваше имя: Вася Пупкин Ваше имя: Вася Пупкин

Теперь давайте познакомимся подробнее с методами, которые есть у string .

Методы для строк

Мы уже видели несколько методов: length , size и append . Однако у строк есть еще много полезных функций, которые упростят вам жизнь:

begin/end - получить итератор для строки
empty - проверка на пустоту
clear - очистка строки
front/back - получить первый/последний символ
insert - вставить подстроку
erase - удалить подстроку
replace - изменить подстроку
find - найти подстроку
compare - сравнить две строки

string — это контейнер в C++. Как и другие контейнеры в C++, он предоставляет возможность обхода своих элементов. Для этого можно использовать итераторы, получаемые с помощью методов begin и end :

string s = "123"; for (auto it = s.begin(); it != s.end(); it++)  cout  <*it  <" "; >

Вывод данной программы:

1 2 3

Чтобы получить вывод 3 2 1 , нужно использовать методы rbegin / rend вместо begin / end .

Вместо того, чтобы писать s.length() == 0 , мы можем воспользоваться методом empty :

string s = ""; cout  "s token operator"> (s.empty() ? "" : s)  endl;

Метод clear позволяет нам очистить существующую строку:

string s = "Длинная строка"; cout  "s token operator"> s  endl; s.clear(); cout  "s token operator"> (s.empty() ? "" : s)  endl;

s = Длинная строка s =

Вместо обращения к индексам 0 и s.length() - 1 напрямую, можно воспользоваться методами front и back :

string s = "12345"; cout  "front token operator"> s.front()  endl; cout  "back token operator"> s.back()  endl;

front = 1 back = 5

Метод insert позволяет нам добавить символы в любую часть существующей строки:

string s = "125"; s.insert(2, "34"); cout  "s token operator"> s  endl;

s = 12345

Первый аргумент метода insert указывает, куда вставить. Второй аргумент - это подстрока, которую следует вставить по указанному индексу.

Метод erase удаляет часть строки:

string s = "123__45"; s.erase(3, 2); cout  "s token operator"> s  endl;

s = 12345

erase принимает два аргумента:

позиция, с которой начинать удалять
сколько символов нужно удалить

Метод replace является комбинацией методов erase и insert :

string s = "12__5"; s.replace(2, 2, "34"); cout  "s token operator"> s  endl;

s = 12345

Метод replace принимает:

позиция, с которой начинать замену
количество символов, которые нужно заменить
строка, на которую нужно заменить

Метод find позволяет нам найти подстроку в другой строке. Данный метод принимает строку, которую нужно найти. В случае если строку удалось найти, мы получим индекс первого вхождения данной подстроки. Если же подстроку найти не удалось, find вернет -1 :

string s = "Не имей сто рублей, а имей сто друзей."; int index = s.find("сто"); cout  "индекс первого вхождения \"сто\" token operator"> index  endl; index = s.find("миллион"); cout  "index token operator"> index  endl;

Вывод данной программы:

индекс первого вхождения "сто" = 14 index = -1

Вас может удивить индекс вхождения подстроки “сто”. Все дело в том, что string хранит набор байт. Русские символы занимают два байта в отличии от пробела или цифр. Получается: “Не” - 4 байта, ” ” - 1 байт, “имей” - 8 байт, ” ” - 1 байт. В сумме - 14 байт. Вы можете подробнее почитать почему разные символы используют разное количество байт в статье про UTF-8.

Что будет выведено на экран:

string s = "Привет, мир!"; int index = s.find("мир"); cout  "index token operator"> index  endl;

В строке “Привет, мир!” подстрока “мир” начинается после “Привет, “. “Привет, ” занимает 14 байт (2 * 6 байта для слова “Привет” и 2 байта на запятую с пробелом), поэтому index равен 14 .

Закончим мы на методе compare . Данный метод позволяет нам сравнить две строки и узнать, какая из них лексикографически больше. a.compare(b) вернет:

Вот наглядный пример:

string a = "123"; string b = "43"; string c = "1234"; cout  "123.compare(123 ) token operator"> a.compare(a)  endl; cout  "123.compare(43 ) token operator"> a.compare(b)  endl; cout  "123.compare(1234) token operator"> a.compare(c)  endl; cout  "43 .compare(1234) token operator"> b.compare(c)  endl;

123.compare(123 ) = 0 123.compare(43 ) = -1 123.compare(1234) = -1 43 .compare(1234) = 1

Если вывод вам кажется неправильным, я советую почитать подробнее про лексикографический порядок по ссылке выше.

Использование front и back :
Напишите программу, которая:
- Запрашивает у пользователя строку.
- Используя методы front и back , выводит на экран первый и последний символы этой строки.
Редактирование строки:
Разработайте программу, которая:
- Запрашивает у пользователя исходную строку.
- Предоставляет меню с 4 опциями: insert , erase , replace , и find .
- В зависимости от выбора пользователя, программа предоставляет инструкции для использования соответствующего метода и выводит результат.
Сравнение строк с помощью compare :
Напишите программу, которая:
- Запрашивает у пользователя две строки.
- Использует метод compare для сравнения этих строк.
- Выводит на экран результат сравнения (какая строка лексикографически больше, или если они равны).

Сколько байт занимает string в c