C++. Работа со строками. Класс string

Использование класса string со строками типа char с размещением 0 в конце — достаточно распространенное явление. Это понятие ввели как альтернативный вариант заверения строки распространенному ранее способу. Строки, которые имеют в конце знак «0», называют еще С-строками.

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

На фото изображено окно программы Visual Studio Express.

Что такое String и ее типы

Строка заключает в себе некое содержание и входит в перечень компонентов типа string. Хранение контеста в середине конструкции представляет собой четкое построение соединения комплектующих, предназначенные исключительно для чтения. Завершение строки не несет в себе знаки С# нуль-символов.

Это объясняет почему количество их может быть любое, при внедрении в текст. Объекты char количеством своих вхождений, определяют такое свойство как lengh. Разницу составляет число символов Юникода.

Чтобы получить доступ к кодовым точкам Юникода необходимо использовать объект StrіngІnfo.

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

#include <string>
 // …
std::string name;
// …

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

std::string name(«Sasha»); // инициализируем переменную name строковым литералом «Sasha»
name = «Masha»; // присваиваем переменной name строковый литерал «Masha»

Кроме этого в строках могут содержаться и прочие элементы:

std::string myID(«34»); // «34» здесь — это не целое число 34!

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

  • в виде строковых неизменных величин;
  • массивными знаками;
  • через указатель на определенный пример;
  • подразумевая конкретные значения.

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

Помимо этого есть определенный термин – строковая константа. Это определенная последовательность символов, которая заключена в кавычки. Чтобы получить конкретный отклик строка обязательно размещает в конце нуль-символом. Его целочисленное значение также должно равняться 0.

После того, как будет объявлена неизменяемая часть, ее наождения происходит в оперативной памяти компьютера, включая сразу нулевой байт. Чаще всего для сохранности используются ячейки, которые идут одна за одной. На одну строку выделяется 1 байт.

Операции и работа со строками Си производятся при определенных условиях. Чтобы внести в строку служебные символы, необходимо использовать специальные символьные комбинации. Перед расположением кавычек должен идти ‘\»‘.

Статическая память размещает в себе неизменные строчные значения. Адрес их обозначается цепью определений первичного адреса в двойных кавычках.

Случается, что строковые константы могут использоваться в разговоре с собеседником. Функции подразумевают размещение указателя printf().

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

char m[82];

Компилятор может и самостоятельно определить размер предоставляемого массива символов. Для этого инициализация задается при объявлении строковой константы:

char m2[]=»Горные вершины спят во тьме ночной.»;
char m3[]={‘Т’,’и’,’х’,’и’,’е’,’ ‘,’д’,’о’,’л’,’и’,’н’,’ы’,’ ‘,’п’,’о’,’л’,’н’,’ы’,’ ‘,’с’,’в’,’е’,’ж’,’е’,’й’,’ ‘,’м’,’г’,’л’,’о’,’й’,’\0′};

Примером указания имен в этом случае могут быть:

  • m2       эквивалентно &m2[0]
  • m2[0]     эквивалентно ‘Г’
  • m2[1]     эквивалентно ‘o’
  • m3       эквивалентно &m3[0]
  • m3[2]     эквивалентно ‘x’

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

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

char m2[80]=»Горные вершины спят во тьме ночной.»;

Еще одним вариантом задания строки может стать специальный символ определенного типа.

char *m4;

Если использовать переменную m4 для объявления массива, можно присвоить адрес массива:

m4 = m3;
*m4       эквивалентно m3[0]=’Т’
*(m4+1)   эквивалентно m3[1]=’и’

m3 в этом варианте будет выступать значение в качестве указателя. Она неизменна в отличии от m4. Внесение каких-либо иных данных может привести к смене размещения составляющих в устройстве. Операция увеличения доступна для использования указателя на конкретный текст:

m4++;

Порой в программировании требуется выполнить указание символьного массива строк. Для выполнения этой задачи применяют адрес размещения для предоставления последующего доступа к нескольким разным строкам.

char *poet[4] = {«Погиб поэт!», «- невольник чести -«,
«Пал,» , «оклеветанный молвой…»};

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

Тексты в кавычках означают то же, что инициализация каждой строки. При помощи запятой разделяются соседние последовательности.

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

char poet[4][23];

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

Описание сводного массива представляет собой следующий вид:

сhar *poet[4];

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

Поиск символа в строке С и операции со строками

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

  • выделить блок оперативной памяти под массив;
  • проинициализировать строку.

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

char *name;
name = (char*)malloc(10);
scanf(«%9s», name);

Ввод строки производят при помощи функции scanf (), размер введенного текста не должен превышать 9 символов. В конце все должно завершаться «\0».

Функции ввода строк

Выполнить это задание доступно только под влиянием сочетания scanf (). Хотя она больше относится к слову, а не к строке. При использовании формата «%s» для ввода, строка вписывается до следующего пустого символа, без его включения. Им может быть пробел, перевод строи или табуляция.

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

char * gets(char *);
или ее аналог
char * gets_s(char *);

Аргументом может выступать указатель на строку, которая выступает инструментом для ввода. Предварительно запрашивается ввод строки, которая размещается в массив, прежде чем вы нажмете кнопку Enter.

Функции вывода строк

Чтобы вывести строку необходимо использовать следующую комбинацию:

printf(«%s», str); // str — указатель на строку

она имеет также и сокращенный вариант:

printf(str);

Еще одним вариантом выполнения этого запроса может стать следующая функция:

int puts (char *s);

Она помогает печатать строку s и после этого направляет курсор на другую строку. Использование функции puts() позволяет выводить строковые константы, которые размещены в кавычка.

Функция ввода символов

Для ввода символов в систему необходимо использовать определенную функцию

char getchar();

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

Функция вывода символов

 Чтобы вывести символы вам необходимо использовать специально предназначенную для этого функцию:

char putchar(char);

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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
char s[80], sym;
int count, i;
system(«chcp 1251»);
system(«cls»);
printf(«Введите строку : «);
gets_s(s);
printf(«Введите символ : «);
sym = getchar();
count = 0;
for (i = 0; s[i] != ‘\0’; i++)
{
if (s[i] == sym)
count++;
}
printf(«В строке\n»);
puts(s);      // Вывод строки
printf(«символ «);
putchar(sym); // Вывод символа
printf(» встречается %d раз», count);
getchar(); getchar();
return 0;
}

Библиотека и класс string С с ее основными функциями

Для запуска полноценного функционирования всей системы, стоит четко знать основные функции класса string C. Чтобы было более удобно их использовать, они приведены немного ниже в виде списка:

  • char *strcat(char *s1, char *s2) — присоединяет s2 к s1, возвращает s1;
  • char *strncat(char *s1, char *s2, int n) — присоединяет не более n символов s2 к s1, завершает строку символом ‘\0’, возвращает s1;
  • char *strсpy(char *s1, char *s2) — копирует строку s2 в строку s1, включая ‘\0’, возвращает;
  • char *strncpy(char *s1, char *s2, int n) — копирует не более n символов строки s2 в строку s1, возвращает s1;
  • int strcmp(char *s1, char *s2) — сравнивает s1 и s2, возвращает значение 0, если строки эквивалентны;
  • int strncmp(char *s1, char *s2, int n) — сравнивает не более n символов строк s1 и s2, возвращает значение 0, если начальные n символов строк эквивалентны;
  • int strlen(char *s) — возвращает количество символов в строке s;
  • char *strset(char *s, char c) — заполняет строку s символами, код которых равен значению c, возвращает указатель на строку s;
  • char *strnset(char *s, char c, int n) — заменяет первые n символов строки s символами, код которых равен c, возвращает указатель на строку s.

Хорошим примером использования этой функции может быть

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char m1[80] = «Первая строка»;
char m2[80] = «Вторая строка»;
char m3[80];
system(«chcp 1251»);
system(«cls»);
strncpy(m3, m1, 6);  // не добавляет ‘\0’ в конце строки
puts(«Результат strncpy(m3, m1, 6)»);
puts(m3);
strcpy(m3, m1);
puts(«Результат strcpy(m3, m1)»);
puts(m3);
puts(«Результат strcmp(m3, m1) равен»);
printf(«%d», strcmp(m3, m1));
strncat(m3, m2, 5);
puts(«Результат strncat(m3, m2, 5)»);
puts(m3);
strcat(m3, m2);
puts(«Результат strcat(m3, m2)»);
puts(m3);
puts(«Количество символов в строке m1 равно  strlen(m1) : «);
printf(«%d\n», strlen(m1));
_strnset(m3, ‘f’, 7);
puts(«Результат strnset(m3, ‘f’, 7)»);
puts(m3);
_strset(m3, ‘k’);
puts(«Результат strnset(m3, ‘k’)»);
puts(m3);
getchar();
return 0;
}

Строки Null и пустые строки

Экземпляром объекта System.String считается пустая строка. Она вмещает в себя нуль символов. Их часто применяют в программировании для представления пустого поля. Инициализация пустых строк происходит следующим образом:

C#Копировать
string s = String.Empty;

Различие между пустой строкой и строкой Null заключается в том, что она не требует ссылки на экземпляр объекта System.String. Если возникает необходимость вызова метода для строи, сразу происходит перенаправление на NullReferenceException.

Эти строки можно использовать для метода string find и compare С. Сравнивать можно и с другими строками. Следующие примеры могут показать способы использования это ссылки на строку Null без вызова заключения:

C#Копировать
static void Main()
{
string str = «hello»;
string nullStr = null;
string emptyStr = String.Empty;

 

string tempStr = str + nullStr;
// Output of the following line: hello
Console.WriteLine(tempStr);

 

bool b = (emptyStr == nullStr);
// Output of the following line: False
Console.WriteLine(b);

 

// The following line creates a new empty string.
string newStr = emptyStr + nullStr;

 

// Null strings and empty strings behave differently. The following
// two lines display 0.
Console.WriteLine(emptyStr.Length);
Console.WriteLine(newStr.Length);
// The following line raises a NullReferenceException.
//Console.WriteLine(nullStr.Length);

 

// The null character can be displayed and counted, like other chars.
string s1 = «\x0» + «abc»;
string s2 = «abc» + «\x0»;
// Output of the following line: * abc*
Console.WriteLine(«*» + s1 + «*»);
// Output of the following line: *abc *
Console.WriteLine(«*» + s2 + «*»);
// Output of the following line: 4
Console.WriteLine(s2.Length);
}

Операции со строками в .NET прекрасно оптимизированы. Чаще всего они никак не влияют на производительность. Если сценарий выполняется сотни тысяч раз, то может проявится определенное замедление процессов.

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

Тип String применяет IEnumerable в качестве метода расширения определенных строк в классе. Для того, чтобы устранить вероятность загромождения, эти методы устранили из общего перечня, но они все же остались доступными.

Ссылка на основную публикацию