Тема 6 Символы и строки

1. Тема 6

Символы и строки

2. Символы

Типы данных стандарта языка C++ от 2011 г.: char (1 байт),
char16_t (2 байта), char32_t (4 байта) и wchar_t (размер
которого определяется при реализации). Типы char и
wchar_t были предусмотрены уже стандартом 1999 г.
Символьный тип char
Значением переменной символьного типа является
одиночная литера из множества всех символов,
представленных в компьютере. Каждому из символов
ставится в соответствие целое число от 0 до 255, которое
называется кодом символа. Соответствие между всеми
символами и их кодами называется таблицей кодировки.
Самой распространённой таблицей кодировки является
ASCII.

3. Символьные константы

Символьная константа - это целое число, записанное в виде
одиночной литеры, заключённой в одиночные кавычки.
Значением символьной константы является её числовой код.
Символьные константы имеют тип char.
Пример:
'g', 'F', 'Q' – латинские буквы, 'Ц', 'г', 'ж' – русские буквы,
'0', '1', '9' – цифры, '.', ',', ':' – знаки препинания.
Замечания:
1) Символы прописных (заглавных) букв и соответствующих
им строчных букв имеют разный код.
2) Символы цифр, латинских (прописных и строчных) и
русских (прописных и строчных) букв в таблице кодировки
расположены друг за другом.
'0' (код 48), '1' (код 49),…, '9' (код 57)
'a' (код 97), 'b' (код 98),…, 'z' (код 122)
'A' (код 65), 'B' (код 66),…, 'Z' (код 90)

4. Служебные символы и символы без графического представления

Символы, генерируемые клавишами Enter, Tab и некоторыми другими не
имеют изображения, так как за этими символами закреплены
определенные действия.
Несколько символов в языке C++ имеют служебное назначение,
например, «двойная кавычка», «апостроф», «обратная наклонная
черта». Служебные символы и символы, у которых нет графического
образа, имеют в C++ специальное представление, называемое эскейппоследовательностью. Данное представление начинается с обратной
наклонной черты (\).
Замечание: ooo – одна, две или три восьмеричные цифры, hh – одна или две
шестнадцатеричные цифры.

5. Представление символов в виде эскейп-последовательности

Представление символов в виде эскейппоследовательности
В виде эсекйп-последовательности можно представлять символы,
используя их коды, определяемые кодовой таблицей. Код символа
задается в восьмеричной или шестнадцатеричной системе
счисления.
Компилятор,
встретив
в
тексте
программы
указанные
последовательности, рассматривает их как один соответствующий
символ.
Пример:
цифру «нуль» можно представить в программе тремя способами:
'0', '\60', '\x30',
так как цифра «нуль» кодируется десятичным числом 48, которое в
восьмеричной системе записывается как 60, а в шестнадцатеричной
как 30.

6. Вывод символа

При выводе значений типа char оператор << создает на экране
изображение соответствующего символа. При необходимости вывести код
символа, его следует преобразовать к типу int с помощью конструкции
int(выр), где выр – выражение типа char.
Программа «Представления символов»
#include <iostream>
#include <clocale>
#include <cstdlib>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
char c = 'A'; // Переменная c инициализируется латинской A
cout << "Код: " << int('A') << ", символ: " << 'A'<< ',' << '\x41' << ',' << '\101' << ',';
cout << c << ',' << char(65) << endl;
system("pause");
return 0;}

7.

Программа «Таблица ASCII»
#include <iostream>
#include <cstdlib>
#include <locale>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
cout << "Код\tСимвол"<< endl;
for(int i=0;i<=255;i++)
cout <<i<<"\t"<<char(i)<<endl;
system("pause");
return 0;
}

8. Ввод символов

Оператор ввода >> пропускает пробельные символы, которые обычно
используются для разделения вводимых данных, поэтому этот оператор неудобен
для ввода одиночных символов, так как пробельные символы будут пропускаться.
Любые символы может вводить функция
int get();
которая извлекает из входного потока очередной символ и возвращает его код.
При вводе из стандартного входного потока cin вызов данной функции должен
иметь вид:
cin.get();
Пример:
int c;
c = cin.get();
Проверить возможность чтения из потока можно с помощью функции
bool eof();
которая возвращает true (или 1), если достигнут конец входного потока. Такая
ситуация возникает после первой неудачной попытки чтения из потока. Если не
достигнут конец входного потока, eof() возвращает false (или 0). Для входного
потока cin вызов данной функции имеет вид
cin.eof();
Замечание: с помощью клавиатуры признак конца входного потока формируется
нажатием двух клавиш Ctrl+Z.

9. Вывод символов

Для вывода одиночного символа c можно
использовать функцию
put(int c);
которая выводит в поток свой аргумент. При выводе в
стандартный выходной поток cout символа c вызов
данной функции должен иметьвид
cout.put(c);
Замечание:
Для вывода одиночного символа c можно также
использовать конструкцию вида
cout << c;

10. Функции ввода-вывода символов в языке С

Подключаемая библиотека: <stdin.h>
• Функция, считывающая символ из входного
потока:
char getchar ();
• Функция, отправляющая символ в выходной
поток:
void putchar (char);
• Обозначение символа конца потока:
EOF

11. Программа «Печать текста по словам»

Программа читает вводимый текст, пока не будет
достигнут конец входного потока, и каждое слово текста
выводит на отдельной строке.
Разделителями слов считаются пробельные символы.
В программе циклически повторяются действия:
1) пропустить пробельные символы;
2) прочитать и вывести символы слова;
3) перейти на новую строку выходного потока.

12. Программа «Печать текста по словам»

#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
char c;
// Здесь будут читаемые символы
while( !cin.eof() ){
// Пока не исчерпан входной поток,
c = cin.get();
// читаем символ из потока
// Пропуск пробельных символов
while(c == ' ' || c == '\n' || c == '\t')
// Пока c – пробельный символ
c = cin.get();
// читаем следующий
// Чтение и вывод символов слова
while(!cin.eof() && c != ' ' && c != '\n' && c != '\t'){ // Пока c не пробел
cout.put(c);
// Вывод символа
c = cin.get();
// Чтение следующего символа
}
cout.put('\n');
// Переход к новой строке, когда закончилось слово
}
system("pause"); return 0; }

13. Операции над символьным типом данных

1)Присваивание (=)
2)Сравнения (==, !=, <, <=, >, >=).
Замечание:
Сравнение переменных происходит путем
сравнения их кодов.
3) Символьные
переменные
и
константы
могут
участвовать в операции над целыми числами точно так
же, как и любые другие переменные целого типа.
Пример:
int i;
char c= '0';
i=c- 'a' +300;

14. Соответствия между символами цифр и их числовым значением

Пусть a (int) значение цифры от 0 до 9 включительно, а c (char)
– соответствующий этому значению символ цифры, тогда
между ними справедливы следующие соотношения:
a=c- '0';
c= '0'+a;
Соответствия между символами букв и их
порядковым номером в алфамите
Пусть c (char) – символ строчной латинской буквы, а a (int) –
соответствующий этой букве номер позиции в алфавите.
Тогда между ними справедливы следующие соотношения:
a=c- 'a'+1;
c= 'a' +a-1;
Аналогичные соотношения для заглавных и русских букв.

15. Программа «Запись десятичного числа в другой системе счисления»

#include <iostream>
#include <cstdlib>
using namespace std;
// prn_numb: печать val в системе счисления с основанием base
void prn_numb(int val, int base = 10) // 10 – значение для base по умолчанию
{ if(val < 0)
{ cout.put('-');
// Вывод знака «минус»
prn_numb(-val, base); }
// Рекурсивный вызов
if(val / base > 0)
// Если число многозначное,
prn_numb(val / base, base);
// печатать старшие цифры
int r = val % base;
// Остаток от деления – значение последней цифры
if(r < 10)
// Используем обычные цифры
cout.put('0' + r);
// Вывод обычной цифры
else
// Используем буквы
cout.put('A' + r - 10); }
void main()
{ prn_numb(31); cout.put(' '); // По умолчанию base = 10
prn_numb(31, 10); cout.put(' '); prn_numb(31, 16); cout.put(' ');
prn_numb(31, 2); cout.put(' ');
prn_numb(31, 8); cout << endl;
system("pause"); }

16. Символьные массивы как строки или терминальная строка

Строка – массив литер, заканчивающийся 0-литерой или нулевым байтом
(символ, код которого равен 0).
Нулевой байт считается концом строки. Символ с нулевым кодом можно
изобразить как '\0'.
Пример:
Массив s, определенный инструкцией:
char s[100];
может содержать строку длиной от 0 до 99 символов, так как из 100 байтов,
выделенных под массив, один байт занимает признак конца строки '\0'.
Замечание: данный символ может занимать любую позицию в массиве,
поэтому в массиве фиксированного размера могут располагаться строки
различной длины. Если s[0] == '\0', то массив s содержит строку нулевой
длины, иначе говоря, пустую строку.
Пример:
• char s1[5]={'h','e','l','l','o'};
- массив литер.
• char s2[6]={'h','e','l','l','o','\0'};
- строка

17. Строковые константы

Строковая константа представляется в тексте программы
последовательностью произвольных символов, заключенной в
двойные кавычки.
Под строковую константу в памяти выделяется массив, в котором
располагаются все символы строки и признак конца строки.
Пример:
Для строки "Здравствуй, Мир!" сформируется массив:
Замечание:
char s[ ]= "Здравствуй, Мир!";
В этом случае компилятор автоматически добавит 0-литеру в конце,
то есть размер массива s равен 17 и имеет вид:
s[17]={'З','д','р','а','в','с','т','в','у','й',',',' ','М','и','р','!','\0'};
Количество элементов также можно посчитать с помощью
выражения:
sizeof (s)/ sizeof (char).

18. Ввод и вывод строк

Для вывода строк можно использовать оператор <<.
При вводе оператором >> в строку включаются все символы до
первого пробела. Ввод строк, содержащих любые символы,
включая пробелы, обеспечивает функция:
int getline(char s[], int n);
которая читает из входного потока не более n – 1 символа до
поступления символа новой строки '\n' или достижения конца
потока.
Символ новой строки вводится с клавиатуры нажатием Enter.
Прочитанный символ новой строки '\n' не включается в массив s.
При вводе из потока cin вызов функции getline() должен иметь вид:
cin.getline(s, n);
Соглашения:
• Признак окончания стринга: 0-литера ('\0') или EOF (конец файла,
Ctrl^z (конец потока)).
• Признак окончания строки: '\n', EOF или 0-литера.

19. Функции языка С для ввода/вывода строк из стандартного потока stdin

Подключаемые библиотеки: <cstdio> или <stdio.h>)
• fflush(stdin) - функция очистки потока stdin, ее следует вызывать перед
вводом каждой строки, если Вы пользуетесь средствами ввода языка С
• Функции char* gets(char* S) и puts(char* S) для неформатного ввода и
вывода строки S. Функция gets(S) не контролирует переполнение
области памяти S
• Функции char* fgets(char* S, unsigned MaxChar, stdin) для
неформатного безопасного ввода строки S (но не более MaxChar-1
символов)
ЗАМЕЧАНИЕ:
Функция fgets в отличие от gets помещает символ '\n', порождаемый
нажатием <ENTER>, в качестве последнего символа в строку s перед
символом конца строки '\0'.
Его можно удалить так:
s[ strlen(s) - 1 ]='\0';

20. Реализация функции getline

#include <iostream>
#include <cstdlib>
#include <locale>
using namespace std;
int Getline (char s[], int lim)
{
int i,c;
for (i=0; i<lim-1 && !cin.eof() && (c=cin.get())!='\n'; i++)
s[i]=c;
s[i]='\0';
return i;
}
int main()
{ setlocale(LC_ALL, "Russian");
char c[100];
int t;
cout<<"Введите строку" <<endl;
t=Getline (c, 100);
cout<<"Строка" <<endl <<c<<"\nДлина строки: "<<t<<endl;
system("pause"); return 0; }

21. Средства работы со строками

Библиотека функций для работы со строками: заголовочный файл сstring.
Функция
unsigned int strlen(const char s[]);
возвращает длину строки s, завершающий символ '\0' не учитывается.
Модификатор const запрещает изменение массива s внутри функции.
Пример:
int n;
n = strlen("Здравствуй"); // n = 10
unsigned int strlen(const char s[])
{
int i;
for (i=0;s[i]!='\0';i++)
;
return i;
}

22. Средства работы со строками

Библиотека функций для работы со строками: заголовочный файл
сstring.
Функция
char* strcpy(char dest[], const char src[]);
копирует строку src в строку dest и возвращает указатель на копию
dest.
char* strcpy(char dest[], const char src[])
{
int i;
for (i=0; src[i]!='\0'; i++)
dest[i]=src[i];
dest[i]='\0';
return dest;
}

23. Средства работы со строками

Библиотека функций для работы со строками: заголовочный файл сstring.
Функция
int strcmp(const char s1[], const char s2[]);
посимвольно сравнивает строки s1 и s2, причем сравниваются коды символов.
Возвращается значение < 0, если первый несовпадающий символ s1 имеет код
меньше кода соответствующего символа s2; значение > 0, если первый
несовпадающий символ s1 имеет больший код, чем соответствующий символ s2 и
0 при полном совпадении строк.
Пример:
int n;
n = strcmp("Мама", "Папа"); // n < 0
int strcmp(const char s1[], const char s2[])
{
int i;
for (i=0; s1[i]!='\0' && s1[i]==s2[i]; i++)
;
return s1[i]-s2[i];
}

24. Программа «Средства работы со строками»

#include <iostream>
#include <cstdlib>
#include <locale>
using namespace std;
unsigned int strlen(const char s[]);
char* strcpy(char dest[], const char src[]);
int strcmp(const char s1[], const char s2[]);
int main()
{
setlocale(LC_ALL, "Russian");
char s1[30],s2[30],s3[30];
cout<<"Введите строку"<<endl;
cin.getline(s1,30);
cout<<"Длина строки: "<< strlen(s1)<<endl;
strcpy(s2,s1);
cout<<"Копия строки: "<<s2<<endl;
cout<<"Введите вторую строку"<<endl;
cin.getline(s3,30);
if (strcmp(s1,s3)>0)
cout<<"Перва строка больше"<<endl;
else if (strcmp(s1,s3)<0)
cout<<"Перва строка меньше"<<endl;
else
cout<<"Строки равны"<<endl;
system("pause");
return 0;
}
// Описание функций

25. Программа «Соединение строк»

#include <iostream>
#include <clocale>
#include <cstdlib>
using namespace std;
// Вставляет s2 в конец s1
// и возвращает указатель на него
char* strcat(char s1[],char s2[])
{
int i; // Индекс массива s1
int j; // Индекс массива s2
// Ищем конец исходного стринга
// и запоминаем его индекс
for (i=0; s1[i]!='\0';i++)
; // Пустое тело
// Копирование из s2 в s1
for (j=0; (s1[i++]=s2[j])!='\0'; j++)
;
return s1;
}
char* strcpy(char dest[], const char src[])
{
int i;
// Просмотр и одновременное копирование
for (i=0; (dest[i]=src[i])!='\0'; i++)
;
return dest;
}
int main()
{
setlocale(LC_ALL, "Russian");
char s1[20],s2[20],s3[40];
cout<<"Введите первую строку"<<endl;
cin.getline(s1,20);
cout<<"Введите вторую строку"<<endl;
cin.getline(s2,20);
strcpy(s3,s1);
strcat(s3,s2);
cout<<s1<<"+"<<s2<<"="<<s3<<endl;
system("pause");
return 0;
}

26. Программа Удаление символа из строки

#include <iostream>
#include <clocale>
#include <cstring>
using namespace std;
// delchar: удаляет символ c из строки s.
// Возвращает длину строки
int delchar(char s[], char c)
{
int i, j=0;
for(i = 0; s[i] != '\0'; ++i) // перебор элементов
if(s[i] != c)
{
// Если символ s[i] не удаляемый,
s[j] = s[i]; // копируется на новое место строки
++j; // Счетчик оставленных в строке символов
}
s[j] = '\0'; // Фиксируем новый конец строки
return j; //Возврат кол-ва символов в строке
}
int main()
{ const int N = 200;
// Размер массива
char st[N];
// Массив для строки
setlocale(LC_ALL, "Russian");
cout << "Введите строку:\n";
cin.getline(st, N);
// Ввод строки
int n = strlen(st); // Находим длину строки
cout << "Длина введенной строки: " << n;
cout << endl;
cout << "Введите удаляемый символ ";
char dc = cin.get();
// Ввод символа
n = delchar(st, dc);
// Вызов функции
cout << "Обработанная строка:\n";
// Настройка на кодовую страницу 866
// для вывода русских символов
setlocale(LC_ALL, ".866");
cout << st << endl;
setlocale(LC_ALL, "Russian");
cout << "ее длина: " << n << endl;
system("pause");
return 0;}

27. Программа «Реверсирование строк»

Реверсирование – это перестановка символов строки в
обратном порядке.
Алгоритм реверсирования.
Вводятся два счетчика: i с начальным значением, равным 0, то
есть номеру первого символа строки, и j с начальным
значением, равным номеру последнего символа строки.
Соответствующие символы меняются местами. Далее счетчик i
увеличивается на 1, а j – уменьшается на 1 и меняются
местами символы s[i] и s[j]. Так продолжается до тех пор, пока
счетчики не «встретятся» на середине строки или не
перескочат друг друга.

28. Программа «Реверсирование строк»

int main()
#include <iostream>
{ setlocale(LC_ALL, "Russian");
#include <clocale>
const int MAX = 100; // Размер строк
#include <cstring>
char orig_s[MAX]; // Исходная строка
#include <cstdlib>
char rev_s[MAX]; // Реверсированная строка
cout << "Введите строку: ";
using namespace std;
cin.getline(orig_s, MAX); // Ввод строки
// revers: перестановка символов s
strcpy(rev_s, orig_s); // Копируем orig_s в rev_s
//в обратном порядке
revers(rev_s); // Реверсирование строки rev_s
void revers(char s[])
cout << "Реверсированная строка: ";
{
cout << rev_s << endl; // Вывод rev_s
int rez = strcmp(orig_s, rev_s); //Сравнение cтрок
int i, j; // Прямой и обратный счетчики
char c; // Символ – результат сравнения строк
char tmp; // Для обмена символов
if(rez < 0)
for(i = 0, j = strlen(s) - 1; i < j; i++, j--){
c = '<';
tmp = s[i];
else if(rez == 0)
s[i] = s[j];
c = '=';
else
s[j] = tmp; }
c = '>';
}
cout << orig_s << c << rev_s << "\n";
system("pause");
return 0; }

29. Функции обработки строк из <сstring>

Функции
обработки
строк
из
<сstring>
Замечание: в VS-2017 часть функций считается устаревшими (небезопасными) в силу
отсутствия контроля за переполнением буфера. С этой целью введены «безопасные»
функции. При необходимости использования ранних версий функций перед обращением к
ним нужно добавить инструкцию препроцессора:
#pragma warning (disable : 4996)
или
#pragma warning (once : 4996)
Для отключения выдачи этих сообщений также можно объявите макрос перед включением
заголовочных файлов стандартных библиотек:
#define _CRT_SECURE_NO_WARNINGS
или (в зависимости от версии заголовочных файлов), возможно,
#define _CRT_SECURE_NO_DEPRECATE.
1) Определение длины строки (не считая '\0').
size_t strlen(const char* Str);
Безопасная версия: size_t strnlen_s( const char *Str, size_t sizeStrBuffer);
2) Добавление S2 в конец S1 (может привести к переполнению области S1).
char* strcat(char* S1, const char* S2);
Безопасная версия (возвращает код ошибки (EINVAL(недопустимый параметр,
используется, чтобы указать различные виды проблем с указанием неправильного
параметра для библиотечной функции) или ERANGE(ошибка диапазона; использование
математических функций, когда значение результата не представимо из-за переполнения.)),
или 0, если успешно):
errno_t strcat_s(char *S1, size_t sizeS1Buff, const char *S2);

30. Функции обработки строк из <сstring>

Функции обработки строк из <сstring>
3) Результат сравнения строк - целое число <0, >0 или ==0 в зависимости
от того, расположена ли строка s1 раньше строки s2 по алфавиту, позднее
или они совпадают.
С учетом регистров:
int strcmp(const char* s1, const char* s2);
Без учета регистров:
int stricmp(const char* s1, const char* s2);
4) Копирование S2 в S1 (функция потенциально опасна)
char* strcpy(char* S1, const char* S2);
Безопасная версия (возвращает код ошибки (EINVAL или ERANGE), либо
0):
errno_t strcpy_s(char *S1, size_t sizeS1Buff, const char *S2);
5) Копирование из s2 n символов в s1 (без символа '\0'):
char* strncpy(char* s1, const char* s2, size_t n);
Безопасная версия (возвращает код ошибки (EINVAL или ERANGE), либо
0):
errno_t strncpy_s(char *S1, size_t sizeS1Buff, const char *S2, size_t n);

31. Функции обработки строк из <сstring>

Функции обработки строк из <сstring>
6) Копирование строки s в динамически выделяемую область памяти
(возвращает указатель на созданную копию):
char* _strdup(const char* s);
7) Возвращает указатель на место первого вхождения строки s1 в s (в
случае отсутствия вхождения нулевой указатель):
char* strstr(char* s, const char* s1);
8) Возвращает указатель на место первого вхождения символа c в s:
char* strchr(char* s, char c);
9) Реверсирует строку:
char* _strrev(char* s);
10) Для выделения слов из строки: слова выделяются из s1, причем строка
s1 при этом изменяется; в Razdelit помещается строка из символовразделителей слов в строке s1; функция возвращает указатели на слова
строки s1; для выделения всех слов функцию надо вызывать в цикле
многократно, причем при втором и последующих вызовах в качестве
параметра s1 надо ставить NULL или nullptr. Признаком того, что все
слова исчерпались, является возврат функцией значения nullptr.
char* strtok(char* s1, char* Razdelit);

32. Стандартный тип string

Стандарт языка C++ предусматривает тип данных
string для работы со строками символов,
определенный в заголовке с таким же именем
string. Этот тип облегчает и делает более
безопасной работу со строками. При работе со
строками как с массивами символов программист
должен следить за размером памяти, выделяемой
под строки, не должен забывать об установке
символа конца строки.
Тип string сам управляет памятью. Кроме того,
можно использовать оператор присваивания (=),
оператор (+) для объединения строк, операторы
сравнения (==, !=, <, <=, >, >=) и другие.

33. Программа Использование типа string

#include <iostream>
#include <clocale>
#include <cstdlib>
#include <string> // Доступ к классу string
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
string s1("Рыба"); // Создание и
string s2 = "Мясо"; // инициализация строк
string s3; // Создание пустой строки
s3 = s1; // Присваивание строк
cout << "s3 = " << s3 << endl; // Вывод строки
s3 = "Ни " + s1 + " ни "; // Склеивание строк
cout << "s3 = " << s3 << endl;
s3 += s2; // Добавление и присваивание строк
cout << "s3 = " << s3 << endl;
s1.swap( s2 ); // Перестановка строк
cout << s1 << " не " << s2 << endl;
string name;
cout << "Длина name = " ;
cout << name.length() << endl; // Длина
cout << "Как Вас зовут? ";
cin >> name;
cout << "Здравствуйте, ";
setlocale(LC_ALL, ".866");
// Для вывода введенных русских букв
cout << name << endl;
setlocale(LC_ALL, "Russian");
cout << "Длина Вашего имени " ;
cout<< name.length() << " букв\n";
system("pause");
return 0;
}

34. Средства C++ для работы со строками: класс string

s.size() // определяет количество элементов в буфере строки s, доступных через s[i].
string::size_type k = s.length(); // определяет количество элементов в буфере строки s
s.append(s2,i,num); //Припишет в конец s num символов из s2 начиная с i-го
s.insert(j,s2); // Вставит строку s2 в s с j-го символа (s раздвинется)
s.insert(j,s2,i,num);//То же, но из s2 будут взяты только num символов с i-го
s.replace(j,nums,s2); //Замена в строке s nums символов с j-го на все символы из s2
s.replace(j,nums,s2,i,num);//То же, но из s2 будут взяты только num символов с i-го
s.erace(j,num); //Удаление из s num символов с j-го
s.compare(j,num,s2); //Сравнение num символов с j-го из строки s с символами из s2
string::size_type p = s.find(s2,j=0);//Поиск c j-й позиции начала первого вхождения s2 в
s
string::size_type p = s.rfind(s2,j); //То же, но поиск – с конца
Замечание: при неудаче p == string::npos
S2 = s.substr(j,num); //Возвращает подстроку из num символов строки s, начиная с j-го
char* ss = s.c_str();//Доступ к буферу(представление строки s как терминальной
строки)