В языке Си отдельного типа данных «строки символов» нет. Работа со строками реализована путем использования одномерных массивов типа char, т.е. строка символов – это одномерный массив типа char, заканчивающийся нулевым байтом.
Нулевой байт – это байт, каждый бит которого равен нулю, при этом для нулевого байта определена символьная константа ´\0´ (признак окончания строки, или нуль-терминатор). Поэтому, если строка должна содержать k символов, то в описании массива необходимо указать k+1 элемент.
Например, char a; - означает, что строка может содержать шесть символов, а последний байт отведен под нулевой.
Строковая константа – это набор символов, заключенных в двойные кавычки. Например:
сhar S=“Работа со строками”;
В конце строковой константы явно указывать символ ´\0´ не нужно.
При работе со строками удобно пользоваться указателями, например:
x = "БГУИР";
x = (i>0)? "положительное":(i<0)? "отрицательное":"нулевое";
Напомним, что для ввода строк обычно используются две стандартные функции:
scanf() - вводит значения для строковых переменных спецификатором ввода %s до появления первого символа “пробел” (символ «&» перед ID строковых данных указывать не надо);
gets() - ввод строки с пробелами внутри этой строки завершается нажатием клавиши ENTER.
Обе функции автоматически ставят в конец строки нулевой байт.
Вывод строк производится функциями printf() или puts() до первого нулевого байта (‘\0’):
printf() не переводит курсор после вывода на начало новой строки;
puts() автоматически переводит курсор после вывода строковой информации в начало новой строки.
Например:
printf(“ Введите строку без пробелов: \n”);
scanf(“%s”,Str);
puts(“ Введите строку ”);
Остальные операции над строками выполняются с использованием стандартных библиотечных функций, описание прототипов которых находятся в файле string.h . Рассмотрим наиболее часто используемые функции.
Функция int strlen (char *S) возвращает длину строки (количество символов в строке), при этом завершающий нулевой байт не учитывается.
char *S1=”Минск!\0”, S2=”БГУИР-Ура!”;
printf(“ %d, %d .”, strlen(S1), strlen(S2));
Результат выполнения данного участка программы:
Функция int strcpy (char *S1, char *S2) - копирует содержимое строки S2 в строку S1.
Функция strcat (char *S1, char *S2) - присоединяет строку S2 к строке S1 и помещает ее в массив, где находилась строка S1, при этом строка S2 не изменяется. Нулевой байт, который завершал строку S1, заменяется первым символом строки S2.
Функция int strcmp
(char *S1, char *S2) сравнивает строки S1 и S2 и возвращает значение <0, если S1
Функции преобразования строки S в число:
Целое: int atoi (char *S);
Длинное целое: long atol (char *S);
Действительное: double atof (char *S);
при ошибке данные функции возвращают значение 0.
Функции преобразования числа V в строку S.
В программе строки могут определяться следующим образом:
- как строковые константы;
- как массивы символов;
- через указатель на символьный тип;
- как массивы строк.
Кроме того, должно быть предусмотрено выделение памяти для хранения строки.
Любая последовательность символов, заключенная в двойные кавычки «» , рассматривается как строковая константа .
Для корректного вывода любая строка должна заканчиваться нуль-символом "\0" , целочисленное значение которого равно 0. При объявлении строковой константы нуль-символ добавляется к ней автоматически. Так, последовательность символов, представляющая собой строковую константу, будет размещена в оперативной памяти компьютера, включая нулевой байт.
Под хранение строки выделяются последовательно идущие ячейки оперативной памяти. Таким образом, строка представляет собой массив символов. Для хранения кода каждого символа строки отводится 1 байт.
Для помещения в строковую константу некоторых служебных символов используются символьные комбинации. Так, если необходимо включить в строку символ двойной кавычки, ему должен предшествовать символ «обратный слеш»: ‘\»‘ .
Строковые константы размещаются в статической памяти. Начальный адрес последовательности символов в двойных кавычках трактуется как адрес строки. Строковые константы часто используются для осуществления диалога с пользователем в таких функциях, как printf() .
При определении массива символов
необходимо сообщить компилятору требуемый размер памяти.
char
m;
Компилятор также может самостоятельно определить размер массива символов, если инициализация массива задана при объявлении строковой константой:
char
m2=;
char
m3={"Т","и","х","и","е"," ","д","о","л","и","н","ы"," ","п","о","л","н","ы"," ","с","в","е","ж","е","й"," ","м","г","л","о","й","\0"
};
В этом случае имена m2 и m3 являются указателями на первые элементы массивов:
- m2 эквивалентно &m2
- m2 эквивалентно ‘Г’
- m2 эквивалентно ‘o’
- m3 эквивалентно &m3
- m3 эквивалентно ‘x’
При объявлении массива символов и инициализации его строковой константой можно явно указать размер массива, но указанный размер массива должен быть больше, чем размер инициализирующей строковой константы:
char
m2="Горные вершины спят во тьме ночной."
;
Для задания строки можно использовать указатель на символьный тип
.
char
*m4;
В этом случае объявление массива переменной m4 может быть присвоен адрес массива:
m4 = m3;
*m4 эквивалентно m3="Т"
*(m4+1) эквивалентно m3="и"
Здесь m3 является константой-указателем. Нельзя изменить m3 , так как это означало бы изменение положения (адреса) массива в памяти, в отличие от m4 .
Для указателя можно использовать операцию увеличения (перемещения на следующий символ):
Массивы символьных строк
Иногда в программах возникает необходимость описание массива символьных строк
. В этом случае можно использовать индекс строки для доступа к нескольким разным строкам.
char
*poet = {"Погиб поэт!", "- невольник чести -"
,
"Пал," , "оклеветанный молвой…"
};
В этом случае poet
является массивом, состоящим из четырех указателей на символьные строки. Каждая строка символов представляет собой символьный массив, поэтому имеется четыре указателя на массивы. Указатель poet
ссылается на первую строку:
*poet
эквивалентно "П"
,
*poet[l]
эквивалентно "-"
.
Инициализация выполняется по правилам, определенным для массивов.
Тексты в кавычках эквивалентны инициализации каждой строки в массиве. Запятая разделяет соседние
последовательности.
Кроме того, можно явно задавать размер строк символов, используя описание, подобное такому:
char
poet;
Разница заключается в том, что такая форма задает «прямоугольный» массив, в котором все строки имеют одинаковую длину.
Свободный массив
Описание
сhar *poet;
определяет свободный массив, где длина каждой строки определяется тем указателем, который эту строку инициализирует. Свободный массив не тратит память напрасно.
Операции со строками
Большинство операций языка Си, имеющих дело со строками, работает с указателями. Для размещения в оперативной памяти строки символов необходимо:
- выделить блок оперативной памяти под массив;
- проинициализировать строку.
Для выделения памяти под хранение строки могут использоваться функции динамического выделения памяти . При этом необходимо учитывать требуемый размер строки:
char
*name;
name = (char
*)malloc(10);
scanf("%9s"
, name);
Для ввода строки использована функция scanf()
, причем введенная строка не может превышать 9 символов. Последний символ будет содержать "\0"
.
Функции ввода строк
Для ввода строки может использоваться функция scanf() . Однако функция scanf() предназначена скорее для получения слова, а не строки. Если применять формат "%s" для ввода, строка вводится до (но не включая) следующего пустого символа, которым может быть пробел, табуляция или перевод строки.
Для ввода строки, включая пробелы, используется функция
char
* gets(char
*);
или её эквивалент
char
* gets_s(char
*);
В качестве аргумента функции передается указатель на строку, в которую осуществляется ввод. Функция просит пользователя ввести строку, которую она помещает в массив, пока пользователь не нажмет Enter .
Функции вывода строк
Для вывода строк можно воспользоваться рассмотренной ранее функцией
printf("%s"
, str); // str - указатель на строку
или в сокращенном формате
printf(str);
Для вывода строк также может использоваться функция
int
puts (char
*s);
которая печатает строку s и переводит курсор на новую строку (в отличие от printf() ). Функция puts() также может использоваться для вывода строковых констант, заключенных в кавычки.
Функция ввода символов
Для ввода символов может использоваться функция
char
getchar();
которая возвращает значение символа, введенного с клавиатуры. Указанная функция использовалась в рассмотренных ранее примерах для задержки окна консоли после выполнения программы до нажатия клавиши.
Функция вывода символов
Для вывода символов может использоваться функция
char
putchar(char
);
которая возвращает значение выводимого символа и выводит на экран символ, переданный в качестве аргумента.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include
#include
#include
int
main() {
char
s, 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.h
Основные функции стандартной библиотеки string.h приведены в таблице.
| Функция | Описание |
|
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", возвращает s1 |
| ); 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; } Результат выполнения |
В этом уроке мы с вами будем обсуждать строки в стиле Си, возможно, вы уже видели эти строки у нас на сайте или в любом другом учебнике. На самом деле, си-строки — это всего лишь массивы символов но, со своей спецификой, таким образом, мы всегда знаем, где конец строки. В этой статье мы рассмотрим несколько функций для работы со строками, например, вы — копирование, конкатенация, получить длину строки.
Что такое строки?
Отметим, что наряду со строками в стиле С, которые, по сути, являются простыми массивами, есть также строковые литералы, такие как этот "literal" . В действительности, что строки, что литералы — это просто наборы символов, расположенных рядом в памяти компьютера. Но между массивами и литералами все таки есть разница, литералы нельзя изменять и строки — можно.
Любая функция, которая принимает строку в стиле С, также может принимать в качестве параметра — литерал. В си также есть некоторые сущности, которые могут выглядеть как строки, хотя, на самом деле, они таковыми не являются. Я сейчас говорю о символах, они заключены в одинарные кавычки, вот пример — "а" , как видите, это не строка. Символ можно, в определенном месте, присвоить строке, но символы не могут быть обработаны в виде строки. Если вы помните, массивы работают как указатели, поэтому, если вы передаете один символ в строку, это будет считаться ошибкой.
Из всего выше сказанного вы должны были понять, что строки — это массивы символов, а строковые литералы — слова, окруженные двойными кавычками. Вот еще один пример литерала:
"Это статическая строка"
Вы еще не забыли про специфику строк, которая упоминалась немного выше? Так вот, Си-строки всегда должны завершаться нулевым символом, буквально — "\0" . Поэтому, чтобы объявить строку, состоящую из 49 букв, необходимо зарезервировать дополнительную ячейку под нулевой символ:
Char myString;
Как видно из примера, длинна массива — 50 символов, 49 из которых займет строка и один, последний займет нулевой символ. Важно помнить, что в конце си-строк всегда должен быть нуль-символ, точно так же как и в конце каждого предложения есть точка. Хотя нуль символ не отображается при выводе строки, он все-равно занимает место в памяти. Поэтому, технически, в массиве из пятидесяти элементов вы смогли бы сохранить только 49 букв, потому что, последний символ нужен для завершения строки. Кроме того, указатели также могут быть использованы в качестве строки. Если вы читали статью про , вы можете сделать нечто подобное:
Char *myString; // указатель типа char myString = malloc(sizeof(*myString) * 64); // выделение памяти
В этом примере мы выделили 64 ячейки в памяти для массива myString . Для высвобождения памяти воспользуйтесь функцией free() .
Free(myString);
Использование строк
Строки полезно использовать тогда, когда вам необходимо выполнять различные операции с текстовой информацией. Например, если вы хотите, чтобы пользователь вводил имя в программу, вы должны использовать строку. Использование функции scanf() для ввода строки — работает, но это может привести к переполнению буфера. Ведь входная строка может оказаться больше, чем размер строки-буфера. Есть несколько способов для решения этой проблемы, но самый простой способ — это использовать , которая объявлена в заголовочном файле
Когда считывает входные данные от пользователя, она будет читать все символы, кроме последнего. После этого в конец считанной строки, поместит нулевой терминатор. Функция fgets() будет cчитывать символы до тех пор, пока пользователь не нажмет Enter . Давайте посмотрим пример использования fgets() :
#include
Первым параметром для fgets() является строка, второй параметр — размер строки и третий параметр — это указатель на входной поток данных.
Результат работы программы:
<ВВОД>...
Как видите, из вывода программы, во входную строку попал символ новой строки — "\n" . Так случилось из-за того, что fgets() считала в строку myString нажатие кнопки Enter и завершила работу. Это означает, что вам может понадобиться вручную удалить символ новой строки. Один из способов сделать это, посимвольный перебор. Давайте доработаем программу и удалим символ новой строки:
#include
Обратите внимание, что если входная строка содержит меньше 100 символов, то в строку попадет и символ новой строки. Поэтому мы можем удалить этот символ, используя простой перебор. В программу мы добавили цикл, в котором перебираем символы строки, строки 12-19 . И когда нам встречается символ новой строки, мы его заменяем нулевым символом, строка 16 . Результат работы программы:
Введите длинную строку: Судьба оставляет свой отпечаток Вы ввели следующую строку: Судьба оставляет свой отпечаток Для закрытия данного окна нажмите <ВВОД>...
На этом пока все. В следующей статье я расскажу вам о специальных функциях для работы со строками.
P.S.: Все мы любим смотреть разные видео-записи, но иногда бывает так, что не всегда получается воспроизвести некоторые форматы видео-файлов. Так вот, решить эту проблему можно с помощью программы — xilisoft converter ultimate . Вы без труда сможете быстро переконвертировать видео из одного формата в другой. Кроме того, эта программа умеет конвертировать еще и аудио-файлы, и анимированные изображения.
Теги: Си строки. Char array.
Строки в си. Введение.
Э
то вводная статья по строкам в си. Более подробное описание и примеры будут, когда мы научимся работать с памятью и указателями.
В компьютере все значения хранятся в виде чисел. И строки тоже, там нет никаких символов и букв.
Срока представляет собой массив чисел. Каждое число соответствует определённому символу, который берётся из таблицы кодировки. При выводе на экран символ отображается определённым образом.
Для хранения строк используются массивы типа char. Ещё раз повторюсь – тип char – числовой, он хранит один байт данных. Но в соответствии с таблицей кодировки каждое из этих чисел связано с символом. И в обратную сторону – каждый символ определяется своим порядковым номером в таблице кодировки.
Например
#include
Мы создали две переменные, одна типа char , другая int . Литера "A" имеет числовое значение 65. Это именно литера, а не строка, поэтому окружена одинарными кавычками. Мы можем вывести её на печать как букву
Printf("display as char %c\n", c);
Тогда будет выведено
A
Если вывести её как число, то будет
65
Точно также можно поступить и с числом 65, которое хранится в переменной типа int
.
Спецсимволы также имеют свой номер
#include
Здесь будет сначала "выведен" звуковой сигнал, затем его числовое значение, затем опять звуковой сигнал.
Строка в си – это массив типа char
, последний элемент которого хранит терминальный символ "\0". Числовое значение этого символа 0, поэтому можно говорить, что массив оканчивается нулём.
Например
#include
Для вывода использовался ключ %s. При этом строка выводится до первого терминального символа, потому что функция printf не знает размер массива word.
Если в этом примере не поставить
Word = "\0";
то будет выведена строка символов произвольной длины, до тех пор, пока не встретится первый байт, заполненный нулями.
#include
В данном случае всё корректно. Строка "ABC" заканчивается нулём, и ею мы инициализируем массив word. Строка text инициализируется побуквенно, все оставшиеся символы, как следует из главы про массивы, заполняются нулями.
Чтение строк
Д ля того, чтобы запросить у пользователя строку, необходимо создать буфер. Размер буфера должен быть выбран заранее, так, чтобы введённое слово в нём поместилось. При считывании строк есть опасность того, что пользователь введёт данных больше, чем позволяет буфер. Эти данные будут считаны и помещены в память, и затрут собой чужие значения. Таким образом можно провести атаку, записав нужные байты, в которых, к примеру, стоит переход на участок кода с вредоносной программой, или логгирование данных.
#include
В данном случае количество введённых символов ограничено 19, а размер буфера на 1 больше, так как необходимо хранить терминальный символ. Напишем простую программу, которая запрашивает у пользователя строку и возвращает её длину.
#include
Так как числовое значение символа "\0" равно нулю, то можно записать
While (buffer != 0) { len++; }
Или, ещё короче
While (buffer) { len++; }
Теперь напишем программу, которая запрашивает у пользователя два слова и сравнивает их
#include
Так как каждая буква имеет числовое значение, то их можно сравнивать между собой как числа. Кроме того, обычно (но не всегда!) буквы в таблицах кодировок расположены по алфавиту. Поэтому сортировка по числовому значению также будет и сортировкой по алфавиту.
Неслучайно тему про строки я поместил в раздел "Массивы". Так как строка это, по сути, массив символов. Вот пример:
char str = "Это просто строка";
Эту же строчку для большего понимания можно записать вот так:
char str = {"Э","т","о"," ","п","р","о","с","т","о","","с","т","р","о","к","а"};
Т.е. все тот же массив, только состоящий уже из символов. Поэтому работать с ним можно, так же как и с целочисленными массивами.
А теперь давайте попробуем работать со строками в c . На вводных уроках мы разбирали, что символы относятся к целочисленным типам, т.е. каждый символ имеет свое числовое значение. Вот пример и его решение:
- требуется перевести введенное слово в верхний регистр:
#include
#include
Int main()
{
char str = "sergey";
str[i] -= 32;
}
for (int i=0; str[i] != "\0";i++){
printf ("%c", str[i]);
}
getch();
Return 0;
}
для получения кода числа просто воспользуйтесь в функции printf спецификатором %d. Да, и еще один важный момент: окончанием любой строки является нуль-терминатор, который обозначается специальным символом - "\0".
Еще одним способом указания строки является объявление ее через char*. Вот пример:
char *str = "provod";
Т.е. создается указатель на строку, который располагается где-то в памяти.
А вот как можно вводить строки через, нам уже родной, опертаор scanf:
char str; scanf("%s", str);
Тут две тонкости:
- знак взятия адреса тут не нужен, так как имя массива, как мы уже знаем, и является адресом
- Длина вводимой строки не должна превышать 15 символов, так как последним обязательно должен быть нуль-терминатор. Причем компилятор сам заполнит этот символ после последнего введенного вашего символа.
Так как язык Си является языком структурным, то существуют уже встроенные функции для работы со строками и с символами. Для обработки строк вам понадобится подключить файл: ctype.h. Файл содержит функции определения регистра, формата символов. В принципе, все, что вам может понадобится узнать о символе, можно выполнить с помощью функций файла ctype.h
Иногда вам может понадобиться перевести строку в другой тип данных. Для перевода строк в другие типы существует библиотека stdlib. Вот ее функции:
- int atoi (char *str)
- long atol (char *str)
- double atof (char *str)
Иногда эти функции очень помогают, например, когда вам надо извлечь из строки год или цифровое значение. Работа со строками в c (си) является очень важной темой, поэтому постарайтесь вникнуть в этот урок.
