###
  • Интернет
  • Программы
  • Игры
  • Проблемы
  • Windows
  • Социальные сети
  • Android
  • Ios

    • Си как вывести элементы на следующей строке. Работа со строками

    30.08.2019 Сотовые операторы

    Строки. Ввод-вывод строк. Форматированный ввод-вывод. Обработка строк с использованием стандартных функций языка С. Работа с памятью.

    1.1. Объявление и инициализация строк.

    Строкой называется массив символов, который заканчивается пустым символом ‘\0’. Строка объявляется как обычный символьный массив, например,

    char s1; // строка длиной в девять символов

    char *s2; // указатель на строку

    Различие между указателями s1 и s2 заключается в том, что указатель s1 является именованной константой, а указатель s2 – переменной.

    Строковые константы заключаются в двойные кавычки в отличие от символов, которые заключаются в одинарные кавычки. Например,

    “This is a string.”

    Длина строковой константы не может превышать 509 символов по стандарту. Однако, многие реализации допускают строки большей длины.

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

    char s1 = “This is a string.”;

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

    1.2. Ввод-вывод строк.

    Для ввода строки с консоли служит функция

    char* gets (char *str);

    которая записывает строку по адресу str и возвращает адрес введенной строки. Функция прекращает ввод, если встретит символ ‘\n’ или EOF (конец файла). Символ перехода на новую строку не копируется. В конец прочитанной строки помещается нулевой байт. В случае успеха функция возвращает указатель на прочитанную строку, а в случае неудачи NULL.

    Для вывода строки на консоль служит стандартная функция

    int puts (const char *s);

    которая в случае удачи возвращает неотрицательное число, а в случае неудачи – EOF.

    Прототипы функций gets и puts описаны в заголовочном файле stdio.h.

    #include

    printf("Input String: ");

    1.3. Форматированный ввод-вывод.

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

    int scanf (const char *format, …);

    которая в случае успешного завершения возвращает количество единиц прочитанных данных, а в случае неудачи – EOF. Параметр format должен указывать на форматируемую строку, которая содержит спецификации форматов ввода. Количество и типы аргументов, которые следуют после строки форматирования, должны соответствовать количеству и типам форматов ввода, заданным в строке форматирования. Если это условие не выполняется, то результат работы функции непредсказуем.

    Пробел, символы "\t" или "\n" в форматной строке описывают один или более пустых символов во входном потоке, к которым относятся символы: пробел, ‘\t’, ‘\n’, ‘\v’, ‘\f’. Функция scanf пропускает пустые символы во входном потоке.

    Литеральные символы в форматной строке, за исключением символа %, требуют, чтобы во входном потоке появились точно такие же символы. Если такого символа нет, то функция scanf прекращает ввод. Функция scanf пропускает литеральные символы.

    В общем случае спецификация формата ввода имеет вид:

    %[*] [ширина] [модификаторы] тип

    Символ ‘*’ обозначает пропуск при вводе поля, определенного данной спецификацией;

    - ‘ширина’ определяет максимальное число символов, вводимых по данной спецификации;

    Тип может принимать следующие значения:

    c – символьный массив,

    s – строка символов, строки разделяются пустыми символами,

    d – целое число со знаком в 10 с/c,

    i – целое число со знаком, система счисления завит от двух первых цифр,

    u – целое число без знака в 10 с/с,

    o – целое число без знака в 8 с/c,

    х, Х – целое число без знака в 16 с/с,

    e, E, f, g, G – плавающее число,

    p – указатель на указатель,

    n – указатель на целое,

    […] – массив сканируемых символов, например, .

    В последнем случае из входного потока будут вводиться только символы, заключенные в квадратные скобки. Если первый символ внутри квадратных скобок равен ‘^’, то вводятся только те символы, которые не входят в массив. Диапазон символов в массиве задается через символ ‘-‘. При вводе символов ведущие пустые символы и завершающий нулевой байт строки также вводятся.

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

    h – короткое целое,

    l, L – длинное целое или плавающее,

    и используются только для целых или плавающих чисел.

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

    #include

    printf("Input an integer: ");

    scanf("%d", &n);

    printf("Input a double: ");

    scanf(" %lf", &d);

    printf("Input a char: ");

    scanf(" %c", &c);

    printf("Input a string: ");

    scanf(" %s", &s);

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

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

    int printf (const char *format, …);

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

    %[флаги] [ширина] [.точность] [модификаторы] тип

    - ‘флаги’ – это различные символы, уточняющие формат вывода;

    - ‘ширина’ определяет минимальное количество символов, выводимых по данной спецификации;

    - ‘.точность’ определяет максимальное число выводимых символов;

    - ‘модификаторы’ уточняют тип аргументов;

    - ‘тип’ определяет тип аргумента.

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

    %[-] [+ | пробел] [ширина] [l] d

    - – выравнивание влево, по умолчанию – вправо;

    + – выводится знак ‘+’, заметим, что для отрицательных чисел всегда выводится знак ‘-‘;

    ‘пробел’ – в позиции знака выводится пробел;

    d – тип данных int.

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

    %[-] [#] [ширина] [l]

    # – выводится начальный 0 для чисел в 8 c/c или начальные 0x или 0X для чисел в 16 c/c,

    l – модификатор типа данных long;

    u – целое число в 10c/c,

    o – целое число в 8 c/c,

    x, X – целое число в 16 c/c.

    Для вывода чисел с плавающей точкой используется следующий формат вывода:

    %[-] [+ | пробел] [ширина] [.точность]

    "точность" – обозначает число цифр после десятичной точки для форматов f, e и E или число значащих цифр для форматов g и G. Числа округляются отбрасыванием. По умолчанию принимается точность в шесть десятичных цифр;

    f – число с фиксированной точкой,

    e – число в экспоненциальной форме, экспонента обозначается буквой "e",

    E – число в экспоненциальной форме, экспонента обозначается буквой "E",

    g – наиболее короткий из форматов f или g,

    G – наиболее короткий из форматов f или G.

    printf ("n = %d\n f = %f\n e = %e\n E = %E\n f = %.2f", -123, 12.34, 12.34, 12.34, 12.34);

    // печатает: n = 123 f = 12.340000 e = 1.234000e+001 E = 1.234000E+001 f = 12.34

    1.4. Форматирование строк.

    Существуют варианты функций scanf и printf, которые предназначены для форматирования строк и называются соответственно sscanf и sprintf.

    int sscanf (const char *str, const char *format, …);

    читает данные из строки, заданной параметром str, в соответствии с форматной строкой, заданной параметром format. В случае удачи возвращает количество прочитанных данных, а в случае неудачи – EOF. Например,

    #include

    char str = "a 10 1.2 String No input";

    sscanf(str, "%c %d %lf %s", &c, &n, &d, s);

    printf("%c\n", c); // печатает: a

    printf("%d\n", n); // печатает: 10

    printf("%f\n", d); // печатает: 1.200000

    printf("%s\n", s); // печатает: String

    int sprintf (char *buffer, const char *format, …);

    форматирует строку в соответствии с форматом, который задан параметром format и записывает полученный результат в символьный массив buffer. Возвращает функция количество символов, записанных в символьный массив buffer, исключая завершающий нулевой байт. Например,

    #include

    char str = "c = %c, n = %d, d = %f, s = %s";

    char s = "This is a string.";

    sprintf(buffer, str, c, n, d, s);

    printf("%s\n", buffer); // печатает: c = c, n = 10, d = 1.200000, s = This is a string

    1.5. Преобразование строк в числовые данные.

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

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

    int atoi (const char *str);

    char *str = “-123”;

    n = atoi (str); // n = -123

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

    long int atol (const char *str);

    которая в случае успешного завершения возвращает целое число, в которое преобразована строка str, а в случае – неудачи 0. Например,

    char *str = “-123”;

    n = atol (str); // n = -123

    Для преобразования строки в число типа double используется функция

    double atof (const char *str);

    которая в случае успешного завершения возвращает плавающее число типа double, в которое преобразована строка str, а в случае – неудачи 0. Например,

    char *str = “-123.321”;

    n = atof (str); // n = -123.321

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

    long int strtol (const char *str, char **endptr, int base);

    преобразует строку str в число типа long int, которое и возвращает. Параметры этой функции имеют следующее назначение.

    Если аргумент base равен 0, то преобразование зависит от первых двух символов строки str:

    Если первый символ – цифра от 1 до 9, то предполагается, что число представлено в 10 c/c;

    Если первый символ – цифра 0, а второй – цифра от 1 до 7, то предполагается, что число представлено в 8 c/c;

    Если первый символ 0, а второй – ‘Х’ или ‘х’, то предполагается, что число представлено в 16 c/c.

    Если аргумент base равен числу от 2 до 36, то это значение принимается за основание системы счисления и любой символ, выходящий за рамки этой системы, прекращает преобразование. В системах счисления с основанием от 11 до 36 для обозначения цифр используются символы от ‘A’ до ‘Z’ или от ‘a’ до ‘z’.

    Значение аргумента endptr устанавливается функцией strtol. Это значение содержит указатель на символ, который остановил преобразование строки str. В случае успешного завершения функция strtol возвращает преобразованное число, а в случае неудачи – 0. Например,

    n = strtol (“12a”, &p, 0);

    printf (“ n = %ld, %stop = %c, n, *p); // n = 12, stop = a

    n = strtol (“012b”, &p, 0);

    printf (“ n = %ld, %stop = %c, n, *p); // n = 10, stop = b

    n = strtol (“0x12z”, &p, 0);

    printf (“ n = %ld, %stop = %c, n, *p); // n = 18, stop = z

    n = strtol (“01117”, &p, 0);

    printf (“ n = %ld, %stop = %c, n, *p); // n = 7, stop = 7

    unsigned long int strtol (const char *str, char **endptr, int base);

    работает аналогично функции strtol, но преобразует символьное представление числа в число типа unsigned long int.

    double strtod (const char *str, char **endptr);

    преобразует символьное представление числа в число типа double.

    Все функции, перечисленные в этом параграфе, прекращают свою работу при встрече первого символа, который не подходит под формат рассматриваемого числа.

    Кроме того, в случае если символьное значение числа превосходит диапазон допустимых значений для соответствующего типа данных, то функции atof, strtol, strtoul, strtod устанавливают значение переменной errno в ERANGE. Переменная errno и константа ERANGE определены в заголовочном файле math.h. При этом функции atof и strtod возвращают значение HUGE_VAL, функция strtol возвращает значение LONG_MAX или LONG_MIN, а функция strtoul – значение ULONG_MAX.

    Для преобразования числовых данных в символьные строки могут использоваться нестандартные функции itoa, ltoa, utoa, ecvt, fcvt и gcvt. Но лучше для этих целей использовать стандартную функцию sprintf.

    1.6. Стандартные функции для работы со строками.

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

    1. Сравнение строк. Для сравнения строк используются функции strcmp и strncmp.

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

    лексикографически сравнивает строки str1, str2 и возвращает –1, 0 или 1, если строка str1 соответственно меньше, равна или больше строки str2.

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

    лексикографически сравнивает не более чем n первых символов из строк str1 и str2. Функция возвращает –1, 0 или 1, если первые n символов из строки str1 соответственно меньше, равны или больше первых n символов из строки str2.

    // пример сравнения строк

    #include

    #include

    char str1 = "aa bb";

    char str2 = "aa aa";

    char str3 = "aa bb cc";

    printf("%d\n", strcmp(str1, str3)); // печатает: -1

    printf("%d\n", strcmp(str1, str1)); // печатает: -0

    printf("%d\n", strcmp(str1, str2)); // печатает: 1

    printf("%d\n", strncmp(str1, str3, 5)); // печатает: 0

    2. Копирование строк. Для копирования строк используются функции strcpy и strncpy.

    char *strcpy (char *str1, const char *str2);

    копирует строку str2 в строку str1. Строка str2 копируется полностью, включая завершающий нулевой байт. Функция возвращает указатель на str1. Если строки перекрываются, то результат непредсказуем.

    char *strncpy (char *str1, const char *str2, size_t n);

    копирует n символов из строки str2 в строку str1. Если строка str2 содержит меньше чем n символов, то последний нулевой байт копируется столько раз, сколько нужно для расширения строки str2 до n символов. Функция возвращает указатель на строку str1.

    char str2 = "Copy string.";

    strcpy (str1, str2);

    printf (str1); // печатает: Copy string.

    4. Соединение строк. Для соединения строк в одну строку используются функции strcat и strncat.

    char* strcat (char *str1, const char *str2);

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

    char* strncat (char *str1, const char *str2, size_t n);

    присоединяет n символов из строки str2 к строке str1, причем завершающий нулевой байт строки str1 стирается. Функция возвращает указатель на строку str1. если длина строки str2 меньше n, то присоединяются только символы, входящие в строку str2. После соединения строк к строке str1 всегда добавляется нулевой байт. Функция возвращает указатель на строку str1.

    #include

    #include

    char str1 = "String ";

    char str2 = "catenation ";

    char str3 = "Yes No";

    strcat (str1, str2);

    printf ("%s\n", str1); // печатает: String catenation

    strncat (str1, str3, 3);

    printf ("%s\n", str1); // печатает: String catenation Yes

    5. Поиск символа в строке. Для поиска символа в строке используются функции strchr, strrchr, strspn, strcspn и strpbrk.

    char* strchr (const char *str, int c);

    ищет первое вхождение символа, заданного параметром c, в строку str. В случае успеха функция возвращает указатель на первый найденный символ, а в случае неудачи – NULL.

    char* strrchr (const char *str, int c);

    ищет последнее вхождение символа, заданного параметром c, в строку str. В случае успеха функция возвращает указатель на последний найденный символ, а в случае неудачи – NULL.

    #include

    #include

    char str = "Char search";

    printf ("%s\n", strchr (str, "r")); // печатает: r search

    printf ("%s\n", strrchr (str, "r")); // печатает: rch

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

    возвращает индекс первого символа из строки str1, который не входит в строку str2.

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

    возвращает индекс первого символа из строки str1, который входит в строку str2.

    char str = "123 abc";

    printf ("n = %d\n", strspn (str, "321"); // печатает: n = 3

    printf ("n = %d\n", strcspn (str, "cba"); // печатает: n = 4

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

    находит первый символ в строке str1, который равен одному из символов в строке str2. В случае успеха функция возвращает указатель на этот символ, а в случае неудачи – NULL.

    char str = "123 abc";

    printf ("%s\n", strpbrk (str, "bca")); // печатает: abc

    6. Сравнение строк. Для сравнения строк используются функция strstr.

    char* strstr (const char *str1, const char *str2);

    находит первое вхождение строки str2 (без конечного нулевого байта) в строку str1. В случае успеха функция возвращает указатель на найденную подстроку, а в случае неудачи – NULL. Если указатель str1 указывает на строку нулевой длины, то функция возвращает указатель str1.

    char str = "123 abc 456;

    printf ("%s\n", strstr (str, "abc"); // печать: abc 456

    7. Разбор строки на лексемы. Для разбора строки на лексемы используется функция strtok.

    char* strtok (char *str1, const char *str2);

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

    #include

    #include

    char str = "12 34 ab cd";

    p = strtok (str, " ");

    printf ("%s\n", p); // печатает в столбик значения: 12 34 ab cd

    p = strtok (NULL, " ");

    8. Определение длины строки. Для определения длины строки используется функция strlen.

    size_t strlen (const char *str);

    возвращает длину строки, не учитывая последний нулевой байт. Например,

    char str = "123";

    printf ("len = %d\n", strlen (str)); // печатает: len = 3

    1.7. Функции для работы с памятью.

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

    void* memchr (const void *str, int c, size_t n);

    ищет первое вхождение символа, заданного параметром c, в n байтах строки str.

    int memcmp (const void *str1, const void *str2, size_t n);

    сравнивает первые n байт строк str1 и str2.

    void* memcpy (const void *str1, const void *str2, size_t n);

    копирует первые n байт из строки str1 в строку str2.

    void* memmove (const void *str1, const void *str2, size_t n);

    копирует первые n байт из строки str1 в строку str2, обеспечивая корректную обработку перекрывающихся строк.

    void* memset (const void *str, int c, size_t n);

    копирует символ, заданный параметром c, в первые n байтов строки str.

    Хабра, привет!

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

    Разговор о программировании под Linux медленно перешел к тому, что этот человек стал утверждать, что сложность системного программирования на самом деле сильно преувеличена. Что язык Си прост как спичка, собственно как и ядро Linux (с его слов).

    У меня был с собой ноутбук с Linux, на котором присутствовал джентльменский набор утилит для разработки на языке Си (gcc, vim, make, valgrind, gdb). Я уже не помню, какую цель мы тогда перед собой поставили, но через пару минут мой оппонент оказался за этим ноутбуком, полностью готовый решать задачу.

    И буквально на первых же строках он допустил серьезную ошибку при аллоцировании памяти под… строку.

    Char *str = (char *)malloc(sizeof(char) * strlen(buffer));
    buffer - стековая переменная, в которую заносились данные с клавиатуры.

    Я думаю, определенно найдутся люди, которые спросят: «Разве что-то тут может быть не так?».
    Поверьте, может.

    А что именно - читайте по катом.

    Немного теории - своеобразный ЛикБез.

    Если знаете - листайте до следующего хэдера.

    Строка в C - это массив символов, который по-хорошему всегда должен заканчиваться "\0" - символом конца строки. Строки на стеке (статичные) объявляются вот так:

    Char str[n] = { 0 };
    n - размер массива символов, то же, что и длина строки.

    Присваивание { 0 } - «зануление» строки (опционально, объявлять можно и без него). Результат такой же, как у выполнения функций memset(str, 0, sizeof(str)) и bzero(str, sizeof(str)). Используется, чтобы в неинициализированных переменных не валялся мусор.

    Так же на стеке можно сразу проинициализировать строку:

    Char buf = "default buffer text\n";
    Помимо этого строку можно объявить указателем и выделить под нее память на куче (heap):

    Char *str = malloc(size);
    size - количество байт, которые мы выделяем под строку. Такие строки называются динамическими (вследствие того, что нужный размер вычисляется динамически + выделенный размер памяти можно в любой момент увеличить с помощью функции realloc()).

    В случае со стековой переменной, для определения размера массива я использовал обозначение n, в случае с переменной на куче - я использовал обозначение size. И это прекрасно отражает истинную суть отличия объявления на стеке от объявление с аллоцированием памяти на куче, ведь n как правило используется тогда, когда говорят о количестве элементов. А size - это уже совсем другая история…

    Нам поможет valgrind

    В своей предыдущей статье я также упоминал о нем. Valgrind ( , два - небольшой how-to) - очень полезная программа, которая помогает программисту отслеживать утечки памяти и ошибки контекста - как раз те вещи, которые чаще всего всплывают при работе со строками.

    Давайте рассмотрим небольшой листинг, в котором реализовано что-то похожее на упомянутую мной программу, и прогоним ее через valgrind:

    #include #include #include #define HELLO_STRING "Hello, Habr!\n" void main() { char *str = malloc(sizeof(char) * strlen(HELLO_STRING)); strcpy(str, HELLO_STRING); printf("->\t%s", str); free(str); }
    И, собственно, результат работы программы:

    $ gcc main.c $ ./a.out -> Hello, Habr!
    Пока ничего необычного. А теперь давайте запустим эту программу с valgrind!

    $ valgrind --tool=memcheck ./a.out ==3892== Memcheck, a memory error detector ==3892== Copyright (C) 2002-2015, and GNU GPL"d, by Julian Seward et al. ==3892== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info ==3892== Command: ./a.out ==3892== ==3892== Invalid write of size 2 ==3892== at 0x4005B4: main (in /home/indever/prg/C/public/a.out) ==3892== Address 0x520004c is 12 bytes inside a block of size 13 alloc"d ==3892== at 0x4C2DB9D: malloc (vg_replace_malloc.c:299) ==3892== by 0x400597: main (in /home/indever/prg/C/public/a.out) ==3892== ==3892== Invalid read of size 1 ==3892== at 0x4C30BC4: strlen (vg_replace_strmem.c:454) ==3892== by 0x4E89AD0: vfprintf (in /usr/lib64/libc-2.24.so) ==3892== by 0x4E90718: printf (in /usr/lib64/libc-2.24.so) ==3892== by 0x4005CF: main (in /home/indever/prg/C/public/a.out) ==3892== Address 0x520004d is 0 bytes after a block of size 13 alloc"d ==3892== at 0x4C2DB9D: malloc (vg_replace_malloc.c:299) ==3892== by 0x400597: main (in /home/indever/prg/C/public/a.out) ==3892== -> Hello, Habr! ==3892== ==3892== HEAP SUMMARY: ==3892== in use at exit: 0 bytes in 0 blocks ==3892== total heap usage: 2 allocs, 2 frees, 1,037 bytes allocated ==3892== ==3892== All heap blocks were freed -- no leaks are possible ==3892== ==3892== For counts of detected and suppressed errors, rerun with: -v ==3892== ERROR SUMMARY: 3 errors from 2 contexts (suppressed: 0 from 0)
    ==3892== All heap blocks were freed - no leaks are possible - утечек нет, и это радует. Но стоит опустить глаза чуть пониже (хотя, хочу заметить, это лишь итог, основная информация немного в другом месте):

    ==3892== ERROR SUMMARY: 3 errors from 2 contexts (suppressed: 0 from 0)
    3 ошибки. В 2х контекстах. В такой простой программе. Как!?

    Да очень просто. Весь «прикол» в том, что функция strlen не учитывает символ конца строки - "\0". Даже если его явно указать во входящей строке (#define HELLO_STRING «Hello, Habr!\n\0»), он будет проигнорирован.

    Чуть выше результата исполнения программы, строки -> Hello, Habr! есть подробный отчет, что и где не понравилось нашему драгоценному valgrind. Предлагаю самостоятельно посмотреть эти строчки и сделать выводы.

    Собственно, правильная версия программы будет выглядеть так:

    #include #include #include #define HELLO_STRING "Hello, Habr!\n" void main() { char *str = malloc(sizeof(char) * (strlen(HELLO_STRING) + 1)); strcpy(str, HELLO_STRING); printf("->\t%s", str); free(str); }
    Пропускаем через valgrind:

    $ valgrind --tool=memcheck ./a.out -> Hello, Habr! ==3435== ==3435== HEAP SUMMARY: ==3435== in use at exit: 0 bytes in 0 blocks ==3435== total heap usage: 2 allocs, 2 frees, 1,038 bytes allocated ==3435== ==3435== All heap blocks were freed -- no leaks are possible ==3435== ==3435== For counts of detected and suppressed errors, rerun with: -v ==3435== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
    Отлично. Ошибок нет, +1 байт выделяемой памяти помог решить проблему.

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

    Однако, знаете, (strlen(str) + 1) - такое себе решение. Перед нами встают 2 проблемы:

    1. А если нам надо выделить память под формируемую с помощью, например, s(n)printf(..) строку? Аргументы мы не поддерживаем.
    2. Внешний вид. Строка с объявлением переменной выглядит просто ужасно. Некоторые ребята к malloc еще и (char *) умудряются прикручивать, будто под плюсами пишут. В программе где регулярно требуется обрабатывать строки есть смысл найти более изящное решение.
    Давайте придумаем такое решение, которое удовлетворит и нас, и valgrind.

    snprintf()

    int snprintf(char *str, size_t size, const char *format, ...); - функция - расширение sprintf, которая форматирует строку и записывает ее по указателю, переданному в качестве первого аргумента. От sprintf() она отличается тем, что в str не будет записано байт больше, чем указано в size.

    Функция имеет одну интересную особенность - она в любом случае возвращает размер формируемой строки (без учета символа конца строки). Если строка пустая, то возвращается 0.

    Одна из описанных мною проблем использования strlen связана с функциями sprintf() и snprintf(). Предположим, что нам надо что-то записать в строку str. Конечная строка содержит значения других переменных. Наша запись должна быть примерно такой:

    Char * str = /* тут аллоцируем память */; sprintf(str, "Hello, %s\n", "Habr!");
    Встает вопрос: как определить, сколько памяти надо выделить под строку str?

    Char * str = malloc(sizeof(char) * (strlen(str, "Hello, %s\n", "Habr!") + 1)); - не прокатит. Прототип функции strlen() выглядит так:

    #include size_t strlen(const char *s);
    const char *s не подразумевает, что передаваемая в s строка может быть строкой формата с переменным количеством аргументов.

    Тут нам поможет то полезное свойство функции snprintf(), о котором я говорил выше. Давайте посмотрим на код следующей программы:

    #include #include #include void main() { /* Т.к. snprintf() не учитывает символ конца строки, прибавляем его размер к результату */ size_t needed_mem = snprintf(NULL, 0, "Hello, %s!\n", "Habr") + sizeof("\0"); char *str = malloc(needed_mem); snprintf(str, needed_mem, "Hello, %s!\n", "Habr"); printf("->\t%s", str); free(str); }
    Запускаем программу в valgrind:

    $ valgrind --tool=memcheck ./a.out -> Hello, Habr! ==4132== ==4132== HEAP SUMMARY: ==4132== in use at exit: 0 bytes in 0 blocks ==4132== total heap usage: 2 allocs, 2 frees, 1,041 bytes allocated ==4132== ==4132== All heap blocks were freed -- no leaks are possible ==4132== ==4132== For counts of detected and suppressed errors, rerun with: -v ==4132== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) $
    Отлично. Поддержка аргументов у нас есть. Благодаря тому, что мы в качестве второго аргумента в функцию snprintf() передаем ноль, запись по нулевому указателю никогда не приведет к Seagfault. Однако, несмотря на это функция все равно вернет необходимый под строку размер.

    Но с другой стороны, нам пришлось завести дополнительную переменную, да и конструкция

    Size_t needed_mem = snprintf(NULL, 0, "Hello, %s!\n", "Habr") + sizeof("\0");
    выглядит еще хуже, чем в случае с strlen().

    Вообще, + sizeof("\0") можно убрать, если в конце строки формата явно указать "\0" (size_t needed_mem = snprintf(NULL, 0, «Hello, %s!\n\0 », «Habr»);), но это возможно отнюдь не всегда (в зависимости от механизма обработки строк мы можем выделить лишний байт).

    Надо что-то сделать. Я немного подумал и решил, что сейчас настал час воззвать к мудрости древних. Опишем макрофункцию, которая будет вызывать snprintf() с нулевым указателем в качестве первого аргумента, и нулем, в качестве второго. Да и про конец строки не забудем!

    #define strsize(args...) snprintf(NULL, 0, args) + sizeof("\0")
    Да, возможно, для кого-то будет новостью, но макросы в си поддерживают переменное количество аргументов, и троеточие говорит препроцессору о том, что указанному аргументу макрофункции (в нашем случае это args) соответствует несколько реальных аргументов.

    Проверим наше решение на практике:

    #include #include #include #define strsize(args...) snprintf(NULL, 0, args) + sizeof("\0") void main() { char *str = malloc(strsize("Hello, %s\n", "Habr!")); sprintf(str, "Hello, %s\n", "Habr!"); printf("->\t%s", str); free(str); }
    Запускаем с valgrund:

    $ valgrind --tool=memcheck ./a.out -> Hello, Habr! ==6432== ==6432== HEAP SUMMARY: ==6432== in use at exit: 0 bytes in 0 blocks ==6432== total heap usage: 2 allocs, 2 frees, 1,041 bytes allocated ==6432== ==6432== All heap blocks were freed -- no leaks are possible ==6432== ==6432== For counts of detected and suppressed errors, rerun with: -v ==6432== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
    Да, ошибок нет. Все корректно. И valgrind доволен, и программист наконец может пойти поспать.

    Но, напоследок, скажу еще кое-что. В случае, если нам надо выделить память под какую-либо строку (даже с аргументами) есть уже полностью рабочее готовое решение .

    Речь идет о функции asprintf:

    #define _GNU_SOURCE /* See feature_test_macros(7) */ #include int asprintf(char **strp, const char *fmt, ...);
    В качестве первого аргумента она принимает указатель на строку (**strp) и аллоцирует память по разыменованному указателю.

    Наша программа, написанная с использованием asprintf() будет выглядеть так:

    #include #include #include void main() { char *str; asprintf(&str, "Hello, %s!\n", "Habr"); printf("->\t%s", str); free(str); }
    И, собственно, в valgrind:

    $ valgrind --tool=memcheck ./a.out -> Hello, Habr! ==6674== ==6674== HEAP SUMMARY: ==6674== in use at exit: 0 bytes in 0 blocks ==6674== total heap usage: 3 allocs, 3 frees, 1,138 bytes allocated ==6674== ==6674== All heap blocks were freed -- no leaks are possible ==6674== ==6674== For counts of detected and suppressed errors, rerun with: -v ==6674== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
    Все отлично, но, как видите, памяти всего было выделено больше, да и alloc"ов теперь три, а не два. На слабых встраиваемых системах использование это функции нежелательно.
    К тому же, если мы напишем в консоли man asprintf, то увидим:

    CONFORMING TO These functions are GNU extensions, not in C or POSIX. They are also available under *BSD. The FreeBSD implementation sets strp to NULL on error.

    Отсюда ясно, что данная функция доступна только в исходниках GNU.

    Заключение

    В заключение я хочу сказать, что работа со строками в C - это очень сложная тема, которая имеет ряд нюансов. Например, для написания «безопасного» кода при динамическом выделении памяти рекомендуется все же использовать функцию calloc() вместо malloc() - calloc забивает выделяемую память нулями. Ну или после выделения памяти использовать функцию memset(). Иначе мусор, который изначально лежал на выделяемом участке памяти, может вызвать вопросы при дебаге, а иногда и при работе со строкой.

    Больше половины моих знакомых си-программистов (большинство из них - начинающие), решивших по моей просьбе задачу с выделением памяти под строки, сделали это так, что в конечном итоге это привело к ошибкам контекста. В одном случае - даже к утечке памяти (ну, забыл человек сделать free(str), с кем не бывает). Собственно говоря, это и сподвигло меня на создание сего творения, которое вы только что прочитали.

    Я надеюсь, кому-то эта статья будет полезной. К чему я это все городил - никакой язык не бывает прост. Везде есть свои тонкости. И чем больше тонкостей языка вы знаете, тем лучше ваш код.

    Я верю, что после прочтения этой статьи ваш код станет чуточку лучше:)
    Удачи, Хабр!

    Объявление строк

    Строка в языке Си представляет собой одномерный массив символов, последним элементом которой является символ конца строки – нуль (строка, завершающаяся нулем, то есть NULL terminated string).

    Объявление переменной типа строка в языке Си возможно тремя способами, два из которых инициализируют строку во время объявления.

    Первый способ:

    Объявления массива символов (не забудьте добавить место для завершающего нуля):

    Char s;

    Второй способ:

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

    Char s = "Пример инициализации строки";

    Справа от знака присваивания записана строковая константа. В конце строки автоматически добавляется ноль (‘\0’). Константы символьных строк помещаются в класс статической памяти.

    Третий способ:

    Неявное указание, что используется массив. В левой части от знака присваивания указывается указатель на символ:

    Char *s="Второй вариант инициализации";

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

    Char *s;

    Ввод строки со стандартного устройства ввода (клавиатуры)

    Для работы со строками есть набор функций. Для ввода со стандартного устройства ввода (клавиатуры) чаще всего используются библиотечные функциями из модуля стандартного ввода-вывода: scanf и gets .

    Для ввода строки с помощью функции scanf , использует формат «%s » , причем обратите внимание на то, что перед идентификатором строки не используется знак адреса «& » , так как одномерный массив уже представлен указателем на его начало:

    Scanf("%s", s);

    Функция gets() считывает символы до тех пор, пока не достигнет символа перехода на новую строку. Функция принимает все символы вплоть до символа перевода строки, но не включает его. К концу строки добавляется завершающий ноль (‘\0’). Функция gets() помещает считанную с клавиатуры последовательность символов в параметр типа строка и возвращает указатель на эту строку (если операция завершилась успешно), или NULL (в случае ошибки). В приведенном ниже примере при успешном завершении операции, на экран будет выведено две одинаковые строки:

    #include int main() { char s; char *p; p=gets(s); printf(" \n Введена строка %s. ",s); if (p) printf(" \n Введена строка %s. ",p); return 0; }

    Попутно заметим, что функция gets часто используется для ввода лю-бых данных с клавиатуры в виде строки с целью дальнейшего преобразования функцией sscanf к нужному формату или для предварительного анализа вводимых данных, например:

    #include #include #include int main() { char s; int x, err; do { printf(" \n Введите целое число -> "); gets(s); err=sscanf(s, "%d",&x); if (err!=1) printf(" \n Ошибка ввода. "); } while (err!=1); printf("\n Введено целое число -> %d", x); return 0; }

    Вывод строк на стандартное устройство вывода (экран монитора)

    Для вывода строк на стандартное устройство вывода (экран монитора) можно использовать две функции printf и puts . В функции printf в качестве формата передается «%s». Удобство использования этой функции заключается в том, что помимо строки можно сразу выводит данные других типов. Особенность функции puts заключается в том, что после вывода строки автоматически происходит переход на следующую строку.

    Функции для работы со строками

    Для преобразования строк в языке Си предусмотрена библиотека string. Каждая из функций имеет свой формат записи (прототип).

    Наиболее используемые функции рассмотрены в этой статье. — читать

    Пример программ(листинг) работающей со строками

    Теги: Си строки. Char array.

    Строки в си. Введение.

    Э то вводная статья по строкам в си. Более подробное описание и примеры будут, когда мы научимся работать с памятью и указателями. В компьютере все значения хранятся в виде чисел. И строки тоже, там нет никаких символов и букв. Срока представляет собой массив чисел. Каждое число соответствует определённому символу, который берётся из таблицы кодировки. При выводе на экран символ отображается определённым образом.
    Для хранения строк используются массивы типа char. Ещё раз повторюсь – тип char – числовой, он хранит один байт данных. Но в соответствии с таблицей кодировки каждое из этих чисел связано с символом. И в обратную сторону – каждый символ определяется своим порядковым номером в таблице кодировки.
    Например

    #include #include void main() { char c = "A"; int i = 65; printf("display as char %c\n", c); printf("display as int %d\n", c); printf("display as char %c\n", i); printf("display as char %d\n", i); getch(); }

    Мы создали две переменные, одна типа char , другая int . Литера "A" имеет числовое значение 65. Это именно литера, а не строка, поэтому окружена одинарными кавычками. Мы можем вывести её на печать как букву

    Printf("display as char %c\n", c);

    Тогда будет выведено
    A
    Если вывести её как число, то будет
    65
    Точно также можно поступить и с числом 65, которое хранится в переменной типа int .
    Спецсимволы также имеют свой номер

    #include #include void main() { printf("%c", "\a"); printf("%d", "\a"); printf("%c", 7); getch(); }

    Здесь будет сначала "выведен" звуковой сигнал, затем его числовое значение, затем опять звуковой сигнал.
    Строка в си – это массив типа char , последний элемент которого хранит терминальный символ "\0". Числовое значение этого символа 0, поэтому можно говорить, что массив оканчивается нулём.
    Например

    #include #include void main() { char word; word = "A"; word = "B"; word = "C"; word = "\0"; //word = 0; эквивалентно printf("%s", word); getch(); }

    Для вывода использовался ключ %s. При этом строка выводится до первого терминального символа, потому что функция printf не знает размер массива word.
    Если в этом примере не поставить

    Word = "\0";

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

    #include #include void main() { char word = "ABC"; char text = {"H", "E", "L", "L", "O"}; printf("%s\n", word); printf("%s", text); getch(); }

    В данном случае всё корректно. Строка "ABC" заканчивается нулём, и ею мы инициализируем массив word. Строка text инициализируется побуквенно, все оставшиеся символы, как следует из главы про массивы, заполняются нулями.

    Чтение строк

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

    #include #include void main() { char buffer; scanf("%19s", buffer); printf("%s", buffer); getch(); }

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

    #include #include void main() { char buffer; unsigned len = 0; scanf("%127s", buffer); while (buffer != "\0") { len++; } printf("length(%s) == %d", buffer, len); getch(); }

    Так как числовое значение символа "\0" равно нулю, то можно записать

    While (buffer != 0) { len++; }

    Или, ещё короче

    While (buffer) { len++; }

    Теперь напишем программу, которая запрашивает у пользователя два слова и сравнивает их

    #include #include /* Результатом сравнения будет число 0 если слова равны 1 если первое слово больше второго в лексикографическом порядке -1 если второе слово больше */ void main() { char firstWord; //Первое слово char secondWord; //Второе слово unsigned i; //Счётчик int cmpResult = 0; //Результат сравнения scanf("%127s", firstWord); scanf("%127s", secondWord); for (i = 0; i < 128; i++) { if (firstWord[i] > secondWord[i]) { //Больше даже если второе слово уже закончилось, потому что //тогда оно заканчивается нулём cmpResult = 1; break; } else if (firstWord[i] < secondWord[i]) { cmpResult = -1; break; } } printf("%d", cmpResult); getch(); }

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

    В этом уроке мы с вами будем обсуждать строки в стиле Си, возможно, вы уже видели эти строки у нас на сайте или в любом другом учебнике. На самом деле, си-строки — это всего лишь массивы символов но, со своей спецификой, таким образом, мы всегда знаем, где конец строки. В этой статье мы рассмотрим несколько функций для работы со строками, например, вы — копирование, конкатенация, получить длину строки.

    Что такое строки?

    Отметим, что наряду со строками в стиле С, которые, по сути, являются простыми массивами, есть также строковые литералы, такие как этот "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 int main() { char myString; // длинная строка printf("Введите длинную строку: "); fgets(myString, 100, stdin); // считываем из потока ввода строку printf("Вы ввели следующую строку: %s", myString); getchar(); }

    Первым параметром для fgets() является строка, второй параметр — размер строки и третий параметр — это указатель на входной поток данных.

    Результат работы программы:

    <ВВОД>...

    Как видите, из вывода программы, во входную строку попал символ новой строки — "\n" . Так случилось из-за того, что fgets() считала в строку myString нажатие кнопки Enter и завершила работу. Это означает, что вам может понадобиться вручную удалить символ новой строки. Один из способов сделать это, посимвольный перебор. Давайте доработаем программу и удалим символ новой строки:

    #include int main() { char myString; // длинная строка printf("Введите длинную строку: "); fgets(myString, 100, stdin); // читываем из потока ввода строку int i; for (i = 0; i < 100; i++) { if (myString[i] == "\n") { myString[i] = "\0"; break; } } printf("Вы ввели следующую строку: %s", myString); getchar(); }

    Обратите внимание, что если входная строка содержит меньше 100 символов, то в строку попадет и символ новой строки. Поэтому мы можем удалить этот символ, используя простой перебор. В программу мы добавили цикл, в котором перебираем символы строки, строки 12-19 . И когда нам встречается символ новой строки, мы его заменяем нулевым символом, строка 16 . Результат работы программы:

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

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

    P.S.: Все мы любим смотреть разные видео-записи, но иногда бывает так, что не всегда получается воспроизвести некоторые форматы видео-файлов. Так вот, решить эту проблему можно с помощью программы — xilisoft converter ultimate . Вы без труда сможете быстро переконвертировать видео из одного формата в другой. Кроме того, эта программа умеет конвертировать еще и аудио-файлы, и анимированные изображения.