Для чего нужна библиотека string в c
Перейти к содержимому

Для чего нужна библиотека string в c

  • автор:

Заголовочный файл cstring (string.h)

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

Функции библиотеки cstring

Функции копирования
memcpy Скопировать блок данных из памяти.
memmove Переместить блок данных в память.
strcpy Скопировать строку.
strncpy Скопировать n символов строки.
Функции объединения (конкатенации)
strcat Объединение строк.
strncat Добавление n символов к строке.
Функции отношения (сравнения)
memcmp Сравнение двух блоков памяти.
strcmp Сравнение двух строк
strcoll Сравнение двух строк по категориям.
strncmp Сравнение n первых символов двух строк
strxfrm Преобразование строки, с учетом локали.
Функции поиска
memchr Поиск символа в блоке памяти
strchr Найти первое вхождение символа в строке.
strcspn Выполняет поиск первого вхождения в строку str1 любого из символов строки str2 , и возвращает количество символов до найденного первого вхождения.
strpbrk Выполняет поиск первого вхождения в строку str1 любого из символов строки str2 , и возвращает указатель на найденный символ.
strrchr Поиск последнего вхождения указанного символа.
strspn Поиск символов строки str2 в строке str1 . Возвращает длину начального участка строки str1 , который состоит только из символов строки str2 .
strstr Функция ищет первое вхождение подстроки str2 в строке str1 .
strtok Поиск лексем в строке, используя разделители.
Другие
memset Заполнить n байтов блока памяти указанным символом.
strerror Интерпретация кодов ошибок в понятные сообщения об ошибках
strlen Определить длину строки.

Макросы

NULL Нулевой указатель

Типы данных

size_t Беззнаковый интегральный тип данных

Поделиться:

�� Rust Journey: Хотите освоить язык программирования, который завоевывает мир?

�� Илон Маск, один из ведущих инноваторов нашего времени, утверждает, что за Rust будущее. А когда последний раз он ошибался в своих прогнозах? ��

✨ Не упустите свой шанс быть в авангарде IT-революции. Подписывайтесь на канал Rust Journey и начните свой путь в захватывающий мир Rust сегодня!

Новое

  • Особенности Qt: слоты и сигналы, описание QObject и QApplication, виды окон и т.д.
  • Первая программа на Qt:
  • Введение — графическая библиотека Qt
  • Наследование классов
  • Перегрузка операторов в С++ (часть 2)

Библиотека обработки строк string.h

Здесь мы перечислим основные функции, предназначенные для работы со строками. Большинство прототипов этих функций (если не оговорено особо) находится в заголовочном файле string.h.

Строковые функции, в имени которых содержится дополнительная буква n, объявляют числовой параметр, ограничивающий некоторым образом действие функции. Эти функции безопаснее, но медленнее, чем их аналоги, не содержащие букву n. Программные примеры содержат следующие пары функций: strcpy() и strncpy(), strcat() и strncat(), strcmp() и strncmp().

int getchar(); — Возвращает значение символа(если он есть), который пользователь набрал на клавиатуре. После ввода символа нужно нажать клавишу Enter. Заголовочный файл — stdio.h

int getch(); — Аналогично предыдущему, только символ на экране не отображается. Используется чаще для организации задержки выполнения программы. Заголовочный файл — conio.h

int putchar(int c); — Выводит символ c на экран. В случае успеха возвращает сам символ c, в противном случе — EOF . Заголовочный файл — stdio.h

char *gets(char *s); — Читает символы, включая пробелы и табуляции, до тех пор, пока не встретится символ новой строки, который заменяется нулевым символом. Последовательность прочитанных символов запоминается в области памяти, адресуемой аргументом s. В случае успеха возвращает аргумент s, в случае ошибки — нуль. Заголовочный файл — stdio.h

int puts(const char *s); — Выводит строку, заданную аргументом const char *s. Заголовочный файл — stdio.h

char *strcpy (char *dst, const char *src); dst — указатель (Указатели в C++) на буфер назначения. src — указатель (Указатели в C++) на исходную строку. Копировать одну строку в другую. Аналогичная функция strncpy() ограничивает количество копируемых символов. Источник (source) и приемник (destination) являются указателями типа char * или символьными массивами.

char *strcat(char *dest, const char *scr); — Объединяет исходную строку scr и результирующую строку dest, присоединяя первую к последней. Возвращает dest.

char *strncat(char *dest, const char *scr, int maxlen); — Объединяет maxlen символов исходной строки scr и результирующую строку dest, присоединяя часть первой к последней. Возвращает dest.

char *strchr(const char *s, int c); — Ищет в строке s первое вхождение символа c, начиная с начала строки. В случае успеха возвращает указатель на найденный символ, иначе возвращает нуль.

char *strrchr(const char *s, int c); — Аналогично предыдущему, только поиск осуществляется с конца строки.

int strcmp(const char *s1, const char *s2); — Сравнивает две строки. Возвращает отрицательное значение, если s1s2. Параметры — указатели на сравниваемые строки.

int stricmp(const char *s1, const char *s2); — Аналогично предыдущему, только сравнение осуществляется без учета регистра символов.

int strncmp(const char *s1, const char *s2, int maxlen); — Аналогично предыдущему, только сравниваются первые maxlen символов.

int strnicmp(const char *s1, const char *s2, int maxlen); — Аналогично предыдущему, только сравниваются первые maxlen символов без учета регистра.

int strcspn(const char *s1, const char *s2); — Возвращает длину максимальной начальной подстроки строки s1, не содержащей символов из второй строки s2.

int strlen(const char *s); — Возвращает длину строки s — количество символов, предшествующих нулевому символу. wcslen использовать для wchar_t (юникода).

char *strlwr(char *s); — Преобразует все прописные (большие) буквы в строчные (малые) в строке s.
char *strupr(char *s); — Преобразует все строчные (малые) буквы в прописные (большие) в строке s.

char *strnset(char *s, int c, int n); — Заполняет строку s символами c. Параметр n задает количество размещаемых символов в строке.

char *strpbrk(const char *s1, const char *s2); — Ищет в строке s1 первое вхождение любого символа из строки s2. Возвращает указатель на первый найденный символ или нуль — если символ не найден.

char *strrev(char *s); — Изменяет порядок следования символов в строке на обратный (кроме завершающего нулевого символа). Функция возвращает строку s.

char *strset(char *s, int c); — Заменяет все символы строки s заданным символом c.

int strspn(const char *s1, const char *s2); — Вычисляет длину максимальной начальной подстроки строки s1, содержащей только символы из строки s2.

char *strstr(const char *s1, const char *s2); — Ищет в строке s1 строку s2. Возвращает адрес первого символа вхождения строки s2. Если строка отсутствует — возвращает нуль.

char *strtok(char *s1, const char *s2); — Делит исходную строку s1 на лексемы (подстроки), разделенные одним или несколькими символами из строки s2.

#include #include #include using namespace std; int main() { char str[] = "dfaghs8da111adf56756wa7ghedh"; char delim[] = "a87";//что мы считаем разделителями в строке char *word = NULL; word = strtok(str,delim);// первый раз вызываем с явным указанием строки, //для дальнейшего поиска в заданной строке пишем NULL while (word = strtok(NULL,delim)) coutwordendl; } $ ./tststrtok ghs d 111 df56 56w ghedh

double atof(const char *s); — Преобразует строку s в число с плавающей точкой типа double. Заголовочный файл — math.h

int atoi(const char *s); — Преобразует строку s в число типа int. Возвращает значение или нуль, если строку преобразовать нельзя. Заголовочный файл — stdlib.h

long atol(const char *s); — Преобразует строку s в число типа long. Возвращает значение или нуль, если строку преобразовать нельзя. Заголовочный файл — stdlib.h

char *itoa(int value, char *s, int radix); — Преобразует значение целого типа value в строку s. Возвращает указатель на результирующую строку. Значение radix — основание системы счисления, используемое при преобразовании (от 2 до 36). Заголовочный файл — stdlib.h

#include #include using namespace std; void main() { char *w2itoa = NULL; char s11[200]; //выделяем память под строку w2itoa = itoa(43534, s11, 16); coutw2itoa"\n"; }

Конкатенация строк

Конкатенация двух строк означает их сцепление, при этом создается новая, более длинная строка. При объявлении строки

char original[128] = "Test ";
strcat(original, " one, two, three!");

превратит значение первоначальной строки original в «Test one, two, three!»

При вызове функции strcat() убедитесь, что первый аргумент типа char * инициализирован и имеет достаточно места, чтобы запомнить результат. Если c1 адресует строку, которая уже заполнена, а c2 адресует ненулевую строку, оператор strcat(c1, c2); перезапишет конец строки, вызвав серьезную ошибку.

Функция strcat() возвращает адрес результирующей строки (совпадающий с ее первым параметром) и может использоваться как каскад нескольких вызовов функций:

strcat(strcat(c1,c2),c3)

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

#include #include using namespace std; void main() { //Резервирование места для ввода трех строк. char *fam = new char[128]; char *im = new char[128]; char *otch = new char[128]; //Ввод данных. cout  "Enter"  "\n"; cout  "\tSurname: "; cin >> fam; cout  "\tName: "; cin >> im; cout  "\tLastname: "; cin >> otch; //Резервирование места для результата. //Нужно учесть два пробела и результирующий //нулевой символ. char *rez=new char[strlen(fam)+strlen(im)+strlen(otch)+3]; //"Сборка" результата. strcat(strcat(strcpy(rez,fam)," "),im); strcat(strcat(rez," "),otch); //Возврат памяти в кучу. delete [] fam; delete [] im; delete [] otch; //Вывод результата. cout  "\nResult: "  rez; delete [] rez; }

Приведенная программа демонстрируют важный принцип конкатенации строк: всегда инициализируйте первый строковый аргумент. В данном случае символьный массив rez инициализируется вызовом функции strcpy(), которая вставляет fam в rez. После этого программа добавляет пробелы и две другие строки — im и otch. Никогда не вызывайте функцию strcat() с неинициализированным первым аргументом.

Если вы не уверены в том, что в строке достаточно места для присоединяемых подстрок, вызовите функцию strncat(), которая аналогична функции strcat(), но требует числового аргумента, определяющего число копируемых символов. Для строк s1 и s2, которые могут быть либо указателями типа char *, либо символьными массивами, оператор

strncat(s1, s2, 4);

присоединяет максимум четыре символа из s2 в конец строки s1. Результат обязательно завершается нулевым символом.

Существует один способ использования функции strncat(), гарантирующий безопасную конкатенацию. Он состоит в передаче функции strncat() размера свободной памяти строки-приемника в качестве третьего аргумента. Рассмотрим следующие объявления:

const int MAXLEN=128 char s1[MAXLEN] = "Cat"; char s2[] = "in hat";

Вы можете присоединить s2 к s1, формируя строку «Cat in hat», с помощью функции strcat():

strcat(s1, s2);

Если вы не уверены, что в s1 достаточно места, чтобы запомнить результат, используйте альтернативный оператор:

strncat(s1, s2, (MAXLEN-1)-strlen(s1));

Этот способ гарантирует, что s1 не переполнится, даже если s2 нужно будет урезать до подходящего размера. Этот оператор прекрасно работает, если s1 — нулевая строка.

Часто программам приходится выполнять поиск в строках отдельных символов или подстрок, особенно при проверке имен файлов на заданное расширение. Например, после того как пользователю предложили ввести имя файла, проверяется, ввел ли он расширение .ТХТ, и если это так, то выполняется действие, отличное от того, какое было бы выполнено для расширения .ЕХЕ.

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

Поиск символов

Пример использования функции strchr().

#include #include #include using namespace std; void main() { char *filename = new char[128]; cout  "Enter name of file: "; gets(filename); cout  "\nName of file: "  filename  "\n"; if (strchr (filename,'.')) cout  "Name has extension"  "\n"; else strcat (filename,".TXT"); cout  "Name of file: "  filename  "\n"; delete [] filename; }

Данная программа находит расширение в имени файла, выполняя поиск точки среди символов введенной строки. (В имени файла может быть только одна точка, которая должна предшествовать расширению, если оно имеется.) Ключевым в этой программе является оператор

if (strchr (filename,'.')) cout 

Выражение strchr (filename,'.') возвращает указатель на символ точки в строке, адресуемой указателем filename. Если такой символ не найден, функция strchr() возвращает нуль. Поскольку ненулевые значения означают "истину", вы можете использовать функцию strchr() в качестве возвращающей значение "истина"/"ложь". Вы также можете применить функцию strchr() для присваивания указателя на подстроку, начинающуюся с заданного символа. Например, если р - указатель, объявленный как char *, и указатель filename адресует строку TEST.ТХТ, то результат действия оператора p=strchr(filename, '.'); показан на рисунке

Рисунок демонстрирует еще один важный момент, связанный с адресацией указателем не полной строки, а ее части - подстроки. Такими указателями следует пользоваться с большой осторожностью. На рисунке показана только одна строка, TEST.ТХТ, оканчивающаяся нулевым байтом, но два указателя - filename и p. Указатель filename адресует полную строку. А указатель p адресует подстроку внутри того же набора символов. Строковые функции не заботятся о байтах, которые предшествуют их первому символу. Поэтому оператор

puts(p);

отображает подстроку .ТХТ так, будто она полная строковая переменная, а не часть другой строки.

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

delete [] p;

пытаясь тем самым освободить подстроку, адресуемую указателем p, что, несомненно, приведет к разрушению кучи, вызвав ошибку, относящуюся к разряду трудно обнаруживаемых.

Функция strchr() отыскивает первое появление символа в строке. Объявления и операторы

char *p; char s[]="Abracadabra"; p = strchr(s,'a');

присваивают указателю p адрес первой строчной буквы 'а' в строке "Abracadabra".

Функция strchr() рассматривает завершающий нуль строки как значащий символ. Приняв во внимание этот факт, можно узнать адрес конца строки. Учитывая предыдущие объявления, оператор

p = strchr(s,0);

установит указатель p равным адресу подстроки "bra" в конце строки "Abracadabra".

Поиск подстрок

Кроме поиска символов в строке, вы также можете поохотиться и за подстроками. Этот пример демонстрирует этот метод. Данная программа аналогична предыдущей, но устанавливает расширение файла .ТХТ.

#include #include #include using namespace std; void main() { char *filename = new char[128],*p; cout  "Enter name of file: "; gets(filename); cout  "\nName of file: "  filename  "\n"; strupr(filename); p = strstr (filename,".TXT"); if (p) cout  "Name has extension"  "\n"; else { p = strchr (filename,'.'); if (p) *p=NULL; //Удалить любое другое расширение. strcat (filename,".TXT"); } cout  "Name of file: "  filename  "\n"; delete [] filename; }

Эта программа создает имя файла, которое обязательно заканчивается расширением .ТХТ. Чтобы определить, есть ли в имени файла это расширение, программа выполняет оператор

p = strstr (filename,".TXT");

Подобно strchr(), функция strstr() возвращает адрес подстроки или нуль, если искомая строка не найдена. Если же цель будет обнаружена, указатель p установится равным ее адресу, в данном примере - адресу точки в подстроке .ТХТ. Поскольку расширение может быть введено и строчными буквами, программа выполняет оператор

strupr(filename);

чтобы перед вызовом функции strstr() преобразовать буквы оригинальной строки в прописные.

Пример также демонстрирует способ усечения строки в позиции заданного символа или подстроки. Здесь вызывается функция strstr(), чтобы установить указатель p равным адресу первой точки в строке filename. Если результат этого поиска не нулевой, то выполнится оператор, который запишет вместо точки нулевой байт:

*p = NULL;

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

Копирование строк

Оператор присваивания для строк не определен. Если с1 и с2 - символьные массивы, вы не сможете скопировать один в другой следующим образом:

с1 = с2; //.

Но если с1 и с2 объявить как указатели типа char *, компилятор согласится с этим оператором, но вряд ли вы получите ожидаемый результат. Вместо копирования символов из одной строки в другую оператор с1 = с2 скопирует указатель с2 в указатель с1, перезаписав, таким образом, адрес в с1, потенциально потеряв информацию, адресуемую указателем.

Чтобы скопировать одну строку в другую, вместо использования оператора присваивания вызовите функцию копирования строк strcpy(). Для двух указателей с1 и с2 типа char * оператор

strcpy(с1, с2);

копирует символы, адресуемые указателем с2, в память, адресуемую указателем с1, включая завершающие нули. И только на вас лежит ответственность за то, что принимающая строка будет иметь достаточно места для хранения копии.

Аналогичная функция strncpy() ограничивает количество копируемых символов. Если источник (source) и приемник (destination) являются указателями типа char * или символьными массивами, то оператор

strncpy(destination, source, 10);

скопирует до 10 символов из строки, адресуемой указателем source, в область памяти, адресуемую указателем destination. Если строка source имеет больше 10 символов, то результат усекается. Если же меньше - неиспользуемые байты результата устанавливаются равными нулю.

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

Библиотека string.h предоставляет функции для работы со строками (zero-terminated strings) в си, а также несколько функций для работы с массивами, которые сильно упрощают жизнь. Рассмотрим функции с примерами.

  • Копирование
  • Конкатенация (склеивание)
  • Сравнение
  • Поиск
  • Длина строки и заполнение символами
  • Перевод строка-число и число-строка
  • Форматированный ввод и вывод в буфер
  • Работа с локалью

Копирование

void * memcpy (void * destination, const void * source, size_t num);

Копирует участок памяти из source в destination, размером num байт. Функция очень полезная, с помощью неё, например, можно скопировать объект или перенести участок массива, вместо поэлементного копирования. Функция производит бинарное копирование, тип данных не важен. Например, удалим элемент из массива и сдвинем остаток массива влево.

#include #include #include #define SIZE 10 int main() < int a[SIZE] = ; unsigned index; int i; printf("Enter index [0 .. 9]"); scanf("%ud", &index); index = index < SIZE? index: SIZE-1; memcpy(&a[index], &a[index+1], sizeof(int) * (SIZE - index - 1)); for (i = 0; i < SIZE; i++) < printf("%d ", a[i]); >getch(); >

Функция меняет местами две переменные

#include #include #include #include void swap(void* a, void* b, size_t size) < void *tmp = malloc(size); memcpy(tmp, a, size); memcpy(a, b, size); memcpy(b, tmp, size); free(tmp); >int main()

Здесь хотелось бы отметить, что функция выделяет память под временную переменную. Это дорогостоящая операция. Для улучшения производительности стоит передавать функции временную переменную, которая будет создана один раз.

#include #include #include #include void swap(void* a, void* b, void* tmp, size_t size) < memcpy(tmp, a, size); memcpy(a, b, size); memcpy(b, tmp, size); >int main()

void* memmove (void * destination, const void * source, size_t num);

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

#include #include #include void main ()

char* strcpy (char * destination, const char* source );

Копирует одну строку в другую, вместе с нулевым символом. Также возвращает указатель на destination.

#include #include #include #include void main ()

Можно копировать и по-другому

#include #include #include #include void main ()

char* strncpy (char* destination, const char* source, size_t num);

Копирует только num первых букв строки. 0 в конец не добавляется автоматически. При копировании из строки в эту же строку части не должны пересекаться (при пересечении используйте memmove)

#include #include #include #include void main ()

Конкатенация строк

char* strcat (char * destination, const char * source);

Добавляет в конец destination строку source, при этом затирая первым символом нулевой. Возвращает указатель на destination.

char* strncat (char * destination, const char * source, size_t num);

Добавляет в конец строки destination num символов второй строки. В конец добавляется нулевой символ.

#include #include #include void main () < char a[255]; char b[128]; scanf("%127s", a); scanf("%127s", b); strncat(a, b, strlen(b)/2); printf("%s", a); getch(); >

Сравнение строк

int strcmp (const char * str1, const char * str2);

Возвращает 0, если строки равны, больше нуля, если первая строка больше, меньше нуля, если первая строка меньше. Сравнение строк происходит посимвольно, сравниваются численные значения. Для сравнения строк на определённом языке используется strcoll

int strcoll (const char * str1, const char * str2);
int strncmp (const char * str1, const char * str2, size_t num);

сравнение строк по первым num символам
Пример - сортировка массива строк по первым трём символам

#include #include #include #include int cmp(const void *a, const void *b) < return strncmp((char*) a, (char*) b, 3); >void main() < char words[][128] = < "Solar", "Obscurus", "Tempestus", "Ultima", "Pacificus" >; int i; qsort(words, 5, 128, cmp); for (i = 0; i < 5; i++) < printf("%s\n", words[i]); >getch(); >
size_t strxfrm (char * destination, const char * source, size_t num);

Трансформация строки в соответствии с локалью. В строку destination копируется num трансформированных символов строки source и возвращается её длина. Если num == 0 и destination == NULL, то возвращается просто длина строки.

#include #include #include #include void main() < char input[128]; char output[128]; scanf("%127s", input); //Выводи введённую строку printf("%s\n", input); //Проводим преобразование, ничего не меняется strxfrm(output, input, 128); printf("%s\n", output); //Изменяем локаль setlocale(LC_ALL, ".1251"); strxfrm(output, input, 128); printf("%s\n", output); getch(); >

Поиск

void* memchr (void * ptr, int value, size_t num);

Проводит поиск среди первых num байтов участка памяти, на который ссылается ptr, первого вхождения значения value, которое трактуется как unsigned char. Возвращает указатель на найденный элемент, либо NULL.

#include #include #include #include void main() < char str[] = "Hello World!"; char *ptr = NULL; ptr = (char*) memchr(str, '\0', 4000); if (ptr != NULL) < printf("first zero byte address is %p, strlen = %d", ptr, ptr - str); >else < printf("no null byte in memory block"); >getch(); >
char* strchr (char * str, int character);

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

size_t strcspn ( const char * str1, const char * str2 );

Возвращает адрес первого вхождения любой буквы из строки str2 в строке str1. Если ни одно включение не найдено, то возвратит длину строки.
Пример - найдём положение всех гласных в строке

#include #include #include void main() < char str[] = "So if you want to love me\n" "Then darling don't refrain\n" "Or I'll just end up walking\n" "In the cold November rain\n"; char vowels[] = "aeiouy"; int i; i = 0; while (str[i]) < i = i + strcspn(&str[i], vowels); printf("%d ", i); i++; >getch(); >

Здесь обратите внимание на строку i++ после printf. Если бы её не было, то strcspn возвращал бы всегда 0, потому что в начале строки стояла бы гласная, и произошло зацикливание.
Для решения этой задачи гораздо лучше подошла функция, которая возвращает указатель на первую гласную.

char* strpbrk (char * str1, const char * str2)

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

#include #include #include void main() < char str[] = "Cos' it's a bittersweet symphony this life. \n" "Trying to make ends meet, you're a slave to the money then you die."; char vowels[] = "aeiouy"; char *p = NULL; p = strpbrk(str, vowels); while (p) < printf("%c ", *p); p++; p = strpbrk(p, vowels); >getch(); >
char* strrchr (char * str, int character );

Возвращает указатель на последнее вхождение символа в троку.

size_t strspn (const char * str1, const char * str2);

Возвращает длину куска строки str1, начиная от начала, который состоит только из букв строки str2.
Пример - вывести число, которое встречается в строке.

#include #include #include void main() < char str[] = "on 21st of May"; char nums[] = "0123456789"; char number[10]; uintptr_t i; //Определяем, где начинаются цифры size_t start = strcspn(str, nums); //Определяем, где они заканчиваются, относительно start size_t end = strspn(&str[start], nums); for (i = 0; i < end; i++) < printf("%c", str[start+i]); >getch(); >
char* strstr (char * str1, const char * str2);

Возвращает указатель на первое вхождение строки str2 в строку str1.

#include #include #include void main()

char* strtok (char * str, const char * delimiters);

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

#include #include #include void main() < char str[] = "After working in India during the late 1970s and 1980s, " "Shankar's profile in the West began to rise again in the mid-1990s " "as his music found its way into club DJ sets, particularly in London."; char delim[] = " \t\n\,.-"; char *p = strtok(str, delim); while (p != NULL) < printf ("%s\n",p); p = strtok (NULL, delim); >getch(); >

Ещё функции

void * memset (void * ptr, int value, size_t num);

Заполняет блок памяти символами value числом num штук. Например, можно заполнить массив или структуру нулями.

#include #include #include void main() < int arr[10][10]; int i; memset(arr, 0, 10*10*sizeof(int)); for (i = 0; i < 10; i++) < arr[i][i] = 1; >for (i = 0; i < 10; i++) < int j; for (j = 0; j < 10; j++) < printf("%d", arr[i][j]); >printf("\n"); > getch(); >

Самая популярная функция

size_t strlen ( const char * str );

Возвращает длину строки - число символов от начала до первого вхождения нулевого.

Конверсия число-строка и строка-число.

int atoi (const char * str);

Переводит строку в целое

#include #include #include void main()

double atof (const char* str);

Переводит строку в число типа double.

long int atol ( const char * str );

Переводит строку в число типа long Все функции такого рода имеют название XtoY, где X и Y - сокращения типов. A обозначает ASCII. Соответственно, имеется обратная функция itoa (больше нет:)). Таких функций в библиотеке stdlib.h очень много, все их рассматривать не хватит места.

Форматированный ввод и вывод в буфер

Можно также выделить две функции sprintf и sscanf. Они отличаются от printf и scanf тем, что выводят данные и считывают их из буфера. Это, например, позволяет переводить строку в число и число в строку. Например

#include #include #include void main()

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

Работа с локалью

char* setlocale (int category, const char* locale);

Устанавливает локаль для данного приложения. Если locale равно NULL, то setlocale может быть использована для получения текущей локали.

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

Значения параметра category

Имя На что влияет
LC_ALL На всю локаль
LC_COLLATE На поведение strcoll и strxfrm.
LC_CTYPE На поведение функций, работающих с символами.
LC_NUMERIC На десятичный разделитель в числах.
LC_TIME На поведение strftime.

Строка locale содержит имя локали, например "En_US" или "cp1251"

ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 sypachev_s_s@mail.ru Stepan Sypachev students

email

Всё ещё не понятно? – пиши вопросы на ящик

Урок №200. Строковые классы std::string и std::wstring

Стандартная библиотека C++ содержит много полезных классов, но одним из наиболее полезных является std::string. std::stringstd::wstring) — это строковый класс, который позволяет выполнять операции присваивания, сравнения и изменения строк. На следующих нескольких уроках мы подробно рассмотрим строковые классы Стандартной библиотеки С++.

Примечание: Строки C-style обычно называют «строками C-style», тогда как std::string (и std::wstring) обычно называют просто «строками».

Оглавление:

  1. Зачем нужен std::string?
  2. Класс std::string
  3. Функционал std::string
    • Создание и удаление
    • Размер и ёмкость
    • Доступ к элементам
    • Изменение
    • Ввод/вывод
    • Сравнение строк
    • Подстроки и конкатенация
    • Поиск
    • Поддержка итераторов и распределителей
  4. Заключение

Зачем нужен std::string?

Мы уже знаем, что строки C-style используют массивы типа char для хранения целой строки. Если вы попытаетесь что-либо сделать со строками C-style, то вы очень быстро обнаружите, что работать с ними трудно, запутаться легко, а проводить отладку сложно.

Строки C-style имеют много недостатков, в первую очередь связанных с тем, что вы должны самостоятельно управлять памятью. Например, если вы захотите поместить строку Hello! в буфер, то вам сначала нужно будет динамически выделить буфер правильной длины:

char * strHello = new char [ 7 ] ;

Не забудьте учесть дополнительный символ для нуль-терминатора! Затем вам нужно будет скопировать значение:

strcpy ( strHello , "Hello!" ) ;

И здесь вам нельзя прогадать с длиной буфера, иначе произойдет переполнение! И, конечно, поскольку строка выделяется динамически, то вы должны её еще и правильно удалить:

delete [ ] strHello ;

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

Суть в том, что работая со строками C-style, вам нужно помнить множество придирчивых правил о том, что делать безопасно, а что — нет; запоминать много функций, таких как strcat() и strcmp(), чтобы использовать их вместо интуитивных операторов; а также самостоятельно выполнять управление памятью.

К счастью, язык C++ предоставляет гораздо лучший способ для работы со строками: классы std::string и std::wstring. Используя такие концепции С++, как конструкторы, деструкторы и перегрузку операторов, std::string позволяет создавать и манипулировать строками в интуитивно понятной форме и, что не менее важно, выполнять это безопасно! Никакого управления памятью, запоминания странных названий функций и значительно меньшая вероятность возникновения ошибок/сбоев.

Класс std::string

Весь функционал класса std::string находится в заголовочном файле string:

На самом деле в заголовочном файле есть 3 разных строковых класса. Первый — это шаблон класса с именем basic_string<> , который является родительским классом:

namespace std
template < class charT , class traits = char_traits < charT >, class Allocator = allocator < charT >>
class basic_string ;

Вы не будете работать с этим классом напрямую, так что не беспокойтесь о том, что такое traits или Allocator . Значений по умолчанию, которые присваиваются этим объектам, будет достаточно почти во всех мыслимых и немыслимых случаях.

Дальше идут две разновидности basic_string<> :

namespace std
typedef basic_string < char >string ;
typedef basic_string < wchar_t >wstring ;

Это те два класса, которые вы будете использовать. std::string используется для стандартных ASCII-строк (кодировка UTF-8), а std::wstring используется для Unicode-строк (кодировка UTF-16). Встроенного класса для строк UTF-32 нет.

Хотя вы будете напрямую использовать std::string и std::wstring, весь функционал реализован в классе basic_string<> . string и wstring имеют доступ к этому функционалу напрямую. Следовательно, все функции, приведенные ниже, работают как со string, так и с wstring.

Функционал std::string

Создание и удаление:

конструктор — создает или копирует строку;

деструктор — уничтожает строку.

Размер и ёмкость:

capacity() — возвращает количество символов, которое строка может хранить без дополнительного перевыделения памяти;

empty() — возвращает логическое значение, указывающее, является ли строка пустой;

length(), size() — возвращают количество символов в строке;

max_size() — возвращает максимальный размер строки, который может быть выделен;

reserve() — расширяет или уменьшает ёмкость строки.

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

[] , at() — доступ к элементу по заданному индексу.

Изменение:

= , assign() — присваивают новое значение строке;

+= , append(), push_back() — добавляют символы к концу строки;

insert() — вставляет символы в произвольный индекс строки;

clear() — удаляет все символы строки;

erase() — удаляет символы по произвольному индексу строки;

replace() — заменяет символы произвольных индексов строки другими символами;

resize() — расширяет или уменьшает строку (удаляет или добавляет символы в конце строки);

swap() — меняет местами значения двух строк.

Ввод/вывод:

>> , getline() — считывают значения из входного потока в строку;

c_str() — конвертирует строку в строку C-style с нуль-терминатором в конце;

copy() — копирует содержимое строки (которое без нуль-терминатора) в массив типа char;

data() — возвращает содержимое строки в виде массива типа char, который не заканчивается нуль-терминатором.

Сравнение строк:

== , != — сравнивают, являются ли две строки равными/неравными (возвращают значение типа bool);

< , , >= — сравнивают, являются ли две строки меньше или больше друг друга (возвращают значение типа bool);

compare() — сравнивает, являются ли две строки равными/неравными (возвращает -1 , 0 или 1 ).

Подстроки и конкатенация:

+ — соединяет две строки;

substr() — возвращает подстроку.

Поиск:

find — ищет индекс первого символа/подстроки;

find_first_of — ищет индекс первого символа из набора символов;

find_first_not_of — ищет индекс первого символа НЕ из набора символов;

find_last_of — ищет индекс последнего символа из набора символов;

find_last_not_of — ищет индекс последнего символа НЕ из набора символов;

rfind — ищет индекс последнего символа/подстроки.

Поддержка итераторов и распределителей (allocators):

begin(), end() — возвращают «прямой» итератор, указывающий на первый и последний (элемент, который идет за последним) элементы строки;

get_allocator() — возвращает распределитель;

rbegin(), rend() — возвращают «обратный» итератор, указывающий на последний (т.е. «обратное» начало) и первый (элемент, который предшествует первому элементу строки — «обратный» конец) элементы строки. Отличие от begin() и end() в том, что движение итераторов происходит в обратную сторону.

Заключение

Вот и весь функционал std::string. Большинство из этих функций имеют несколько разновидностей для обработки разных типов входных данных, об этом мы еще поговорим.

Хотя функционал достаточно широк, все же есть несколько заметных упущений:

конструкторы для создания строк из чисел;

токенизация/разбиение строк на массивы;

простые функции для получения левой или правой части строки;

конвертация из UTF-8 в UTF-16 и наоборот.

Всё вышеперечисленное вам придется реализовать самостоятельно, либо конвертировать вашу строку в строку C-style (используя функцию c_str()) и тогда уже использовать функционал, который предлагает язык C++.

Примечание: Хотя мы используем string в наших примерах, всё это также применимо и к wstring.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *