Как вставить разрыв строки в строку sql server varchar / nvarchar

Аргументы

char  — строковые данные фиксированного размера. n определяет размер строки в байтах и должно иметь значение от 1 до 8000. Для однобайтовых кодировок, таких как Latin, размер при хранении равен n байт, а количество хранимых символов — тоже n. Для многобайтовых кодировок размер при хранения тоже равен n байт, но количество хранимых символов может быть меньше n. Синонимом по стандарту ISO для типа char является character. Дополнительные сведения о кодировках см. в статье Однобайтовые и многобайтовые кодировки.

varchar  — строковые данные переменного размера. Используйте значение n для определения размера строки в байтах (допускаются значения от 1 до 8000) или используйте max для указания предельного размера столбца вплоть до максимального размера хранилища, что составляет 2^31-1 байт (2 ГБ). Для однобайтовых кодировок, таких как Latin, размер при хранении равен n байт + 2 байта, а количество хранимых символов — n. Для многобайтовых кодировок размер при хранении тоже равен n байт + 2 байта, но количество хранимых символов может быть меньше n. Синонимами по стандарту ISO для типа varchar являются типы charvarying или charactervarying. Дополнительные сведения о кодировках см. в статье Однобайтовые и многобайтовые кодировки.

Оператор static_cast

Если вы хотите вывести символы в виде цифр, а не в виде букв, то вам нужно сообщить cout выводить переменные типа char в виде целочисленных значений. Не очень хороший способ это сделать — присвоить переменной типа int переменную типа char и вывести её:

#include <iostream>

int main()
{
char ch(97);
int i(ch); // присваиваем значение переменной ch переменной типа int
std::cout << i << std::endl; // выводим значение переменной типа int
return 0;
}

1 2 3 4 5 6 7 8 9

#include <iostream> intmain() { charch(97); inti(ch);// присваиваем значение переменной ch переменной типа int std::cout<<i<<std::endl;// выводим значение переменной типа int return; }

Результат:

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

Синтаксис static_cast выглядит следующим образом:

Оператор static_cast принимает значение из в качестве входных данных и конвертирует его в указанный вами .

Пример использования оператора static_cast для конвертации типа char в тип int:

#include <iostream>

int main()
{
char ch(97);
std::cout << ch << std::endl;
std::cout << static_cast<int>(ch) << std::endl;
std::cout << ch << std::endl;
return 0;
}

1 2 3 4 5 6 7 8 9 10

#include <iostream> intmain() { charch(97); std::cout<<ch<<std::endl; std::cout<<static_cast<int>(ch)<<std::endl; std::cout<<ch<<std::endl; return; }

Результат выполнения программы:

Запомните, static_cast принимает в качестве входных данных. Если мы используем переменную в , то эта переменная изменяет свой тип только в стейтменте с оператором static_cast. Процесс конвертации никак не влияет на исходную переменную с её значением! В вышеприведенном примере, переменная остается переменной типа char с прежним значением, чему является подтверждением последний стейтмент с cout.

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

Более подробно о static_cast мы еще поговорим на соответствующем уроке.

Создание и инициализация строки

Так как строка – это массив символов, то объявление и инициализация строки аналогичны подобным операциям с одномерными массивами.

Следующий код иллюстрирует различные способы инициализации строк.

Листинг 1.

  char str;
  char str1 = {'Y','o','n','g','C','o','d','e','r','\0'};
  char str2 = "Hello!";
  char str3[] = "Hello!";

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

В первой строке мы просто объявляем массив из десяти символов. Это даже не совсем строка, т.к. в ней отсутствует нуль-символ \0, пока это просто набор символов.

Вторая строка. Простейший способ инициализации в лоб. Объявляем каждый символ по отдельности. Тут главное не забыть добавить нуль-символ \0.

Третья строка – аналог второй строки

Обратите внимание на картинку. Т.к

символов в строке справа меньше, чем элементов в массиве, остальные элементы заполнятся \0.

Четвёртая строка. Как видите, тут не задан размер. Программа его вычислит автоматически и создаст массив символов нужный длины. При этом последним будет вставлен нуль-символ \0.

Remarks

Часто ошибочно считают, что в типах данных NCHAR(n) и NVARCHAR(n) число n указывает на количество символов. Однако на самом деле число n в NCHAR(n) и NVARCHAR(n) — это длина строки в парах байтов (0–4000). n никогда не определяет количество хранимых символов. То же самое верно и в отношении типов CHAR(n) и VARCHAR(n).
Заблуждение возникает из-за того, что при использовании символов, определенных в диапазоне Юникода 0–65 535, на каждую пару байтов приходится один хранимый символ. Однако в старших диапазонах Юникода (65 536–1 114 111) один символ может занимать две пары байтов. Например, в столбце, определенном как NCHAR(10), Компонент Database Engine может хранить 10 символов, занимающих одну пару байтов (диапазон Юникода 0–65 535), но меньше 10 символов, занимающих две пары байтов (диапазон Юникода 65 536–1 114 111). Дополнительные сведения о хранении символов Юникода и их диапазонах см. в разделе .

Если значение n в определении данных или в инструкции объявления переменной не указано, то длина по умолчанию равна 1. Когда n не задано функцией CAST, длина по умолчанию равняется 30.

Если вы используете nchar или nvarchar, мы рекомендуем:

• использовать nchar, если размеры записей данных в столбцах одинаковые;
• использовать nvarchar, если размеры записей данных в столбцах существенно отличаются;
• использовать nvarchar(max), если размеры записей данных в столбцах существенно отличаются и длина строки может превышать 4000 пар байтов.

Тип sysname — это предоставляемый системой определяемый пользователем тип данных, который функционально эквивалентен типу nvarchar(128) за исключением того, что он не допускает значения NULL. Тип sysname используется для ссылки на имена объектов баз данных.

Объектам, в которых используются типы данных nchar и nvarchar, назначаются параметры сортировки базы данных по умолчанию, если только иные параметры сортировки не назначены с помощью предложения COLLATE.

Для типов данных nchar и nvarchar параметр SET ANSI_PADDING всегда принимает значение ON. Параметр SET ANSI_PADDING OFF не применяется к типам данных nchar или nvarchar.

Префикс N в строковых константах с символами Юникода указывает на входные данные в кодировке UCS-2 или UTF-16 (в зависимости от того, используются ли параметры сортировки с поддержкой дополнительных символов). Без префикса N строка преобразуется в стандартную кодовую страницу базы данных, и определенные символы могут не распознаваться. Начиная с SQL Server 2019 (15.x) при использовании параметров сортировки с поддержкой UTF-8 стандартная кодовая страница может хранить символы Юникода в кодировке UTF-8.

Примечание

Когда строковая константа имеет префикс N и ее длина не превышает максимальную длину строкового типа данных nvarchar (4000), результатом неявного преобразования будет строка в кодировке UCS-2 или UTF-16. В противном случае результатом неявного преобразования будет большое значение nvarchar(max).

Предупреждение

Каждому ненулевому столбцу varchar(max) и nvarchar(max) необходимо дополнительно выделить 24 байта памяти, которые учитываются в максимальном размере строки в 8060 байт во время операции сортировки. Эти дополнительные байты могут неявно ограничивать число ненулевых столбцов varchar(max) или nvarchar(max) в таблице. При создании таблицы или во время вставки данных не возникает особых ошибок (кроме обычного предупреждения о том, что максимальный размер строки превышает максимально допустимое значение в 8060 байт). Такой большой размер строки может приводить к ошибкам (например, ошибке 512), которые пользователи не ожидают во время обычных операций. Примерами операций могут служить обновление ключа кластеризованного индекса или сортировка полного набора столбцов.

Примеры

A. Отображение значения по умолчанию n при использовании в объявлении переменной

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

В. Преобразование данных для отображения

В следующем примере два столбца преобразуются в символьные типы, после чего к ним применяется стиль, применяющий к отображаемым данным конкретный формат. Тип money преобразуется в символьные данные. К нему применяется стиль 1, отображающий значения с запятыми между каждой группой из трех цифр, отсчитывая влево от десятичной точи, и каждой группой из двух цифр, отсчитывая вправо от десятичной точки. Тип datetime преобразуется в символьные данные. К нему применяется стиль 3, отображающий данные в формате дд/мм/гг. В предложении WHERE тип money приводится к символьному типу для выполнения операции сравнения строк.

Результирующий набор:

Г. Преобразование данных uniqueidentifier

В следующем примере значение преобразуется в тип данных .

Следующий пример показывает усечение данных, когда значение является слишком длинным для преобразования в заданный тип данных. Так как тип данных uniqueidentifier ограничен 36 символами, все символы, выходящие за пределы этой длины, будут усечены.

Результирующий набор:

Строки в стиле C

Строка в стиле C – это просто массив символов, в котором используется нулевой терминатор. Нулевой терминатор – это специальный символ (‘\0’, ASCII код 0), используемый для обозначения конца строки. В более общем смысле, строка в стиле C называется строкой с завершающим нулем.

Чтобы определить строку в стиле C, просто объявите массив и инициализируйте его строковым литералом:

Хотя «string» состоит только из 6 букв, C++ автоматически добавляет нулевой терминатор в конец строки за нас (нам не нужно включать его самим). Следовательно, на самом деле представляет собой массив длиной 7!

Доказательство этого можно увидеть в следующей программе, которая выводит длину строки, а затем значения ASCII всех символов:

Эта программа дает следующий результат:

Этот 0 – это код ASCII нулевого терминатора, добавленного в конец строки.

При объявлении строк таким образом рекомендуется использовать и позволить компилятору самому вычислить длину массива. Таким образом, если позже вы измените строку, вам не придется изменять длину массива вручную.

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

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

Эта программа напечатает:

При печати строки в стиле C печатает символы до тех пор, пока не встретит нулевой терминатор. Если вы случайно перезапишете нулевой терминатор строки (например, присвоив что-то элементу ), вы получите не только все символы в строке, но просто продолжит печатать всё из соседних слотов памяти до тех пор, пока не наткнется на 0!

Обратите внимание, что это нормально, если массив по размеру больше, чем содержащаяся в нем строка:

В этом случае будет напечатана строка «Alex», и остановится на нулевом терминаторе. Остальные символы в массиве игнорируются.

Обработка строк

В библиотеке string.h содержаться функции для различных действий над строками. Функция вычисления длины строки:size_t strlen(const char *string);

Пример:

char str[] = «1234»; int n = strlen(str); //n == 4

Функции копирования строк:

char * strcpy(char * restrict dst, const char * restrict src); char * strncpy(char * restrict dst, const char * restrict src, size_t num);

Функции сравнения строк:

int strcmp(const char *string1, const char *string2); int strncmp(const char *string1, const char *string2,size_t num);

Функции осуществляют сравнение строк по алфавиту и возвращают:

положительное значение – если string1 больше string2; отрицательное значение – если string1 меньше string2; нулевое значение – если string1 совпадает с string2;

Функции объединения (конкатенации) строк:

char * strcat(char * restrict dst, const char * restrict src); char * strncat(char * restrict dst, const char * restrict src, size_t num);

Функции поиска символа в строке:

char * strchr(const char *string, int c); char * strrchr(const char *string, int c);

Функция поиска строки в строке:char * strstr(const char *str, const char *substr);

Пример:

char str[] = «Строка для поиска»; char *str1 = strstr(str,»для»); //str1 == «для поиска»

Функция поиска первого символа в строке из заданного набора символов:size_t strcspn(const char *str, const char *charset);

Функции поиска первого символа в строке не принадлежащему заданному набору символов:size_t strspn(const char *str, const char *charset);

Функции поиска первого символа в строке из заданного набора символов:char * strpbrk(const char *str, const char *charset);

Функция поиска следующего литерала в строке:char * strtok(char * restrict string, const char * restrict charset);

_fcvt

char* _fcvt(
   double number,
   int num_dec,
   int* dec_pos,
   int* has_sign
);

Возвращает адрес буфера, содержащего строковое представление дробного числа
number в десятичной форме; заметим, что этот буфер
перезаписывается при каждом вызове функции. Через параметр
num_dec необходимо передать требуемое количество
десятичных знаков; при необходимости исходное число будет округлено или дополнено
нулями. В переменную по адресу dec_pos будет записана
требуемая позиция десятичной точки в возвращенной строке; при этом, если целая часть
числа равна 0, то по этому адресу будет записано отрицательное или нулевое значение.
В переменную по адресу has_sign записывается ненулевое
значение для отрицательного исходного числа и 0 — в противном случае.

Таким образом, возвращаемая данной функцией строка не содержит ни знака, ни десятичной
точки; ниже рассматривается несколько примеров:

Что использовать: ‘\n’ или std::endl?

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

При использовании std::cout, данные для вывода могут помещаться в буфер, т.е. std::cout может не отправлять данные сразу же на вывод. Вместо этого он может оставить их при себе на некоторое время (в целях улучшения производительности).

И , и оба переводят курсор на следующую строку. Только еще гарантирует, что все данные из буфера будут выведены, перед тем, как продолжить.

Так когда же использовать , а когда ?

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

Обратите внимание, это может повлечь за собой незначительное снижение производительности, особенно если запись на устройство происходит медленно (например, запись файла на диск)

   Используйте  во всех остальных случаях.

В чём разница между одинарными и двойными кавычками при использовании с символами?

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

char ch(’56’); // переменная типа char может хранить только один символ

1	charch(’56’);// переменная типа char может хранить только один символ

Текст, который находится в двойных кавычках, называется строкой (например, ). Строка (тип string) — это набор последовательных символов.

Вы можете использовать литералы типа string в коде:

std::cout << «Hello, world!»; // «Hello, world!» — это литерал типа string

1	std::cout<<«Hello, world!»;// «Hello, world!» — это литерал типа string

Более подробно о типе string мы поговорим на соответствующем уроке.

Управление строками в стиле C

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

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

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

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

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

Поскольку поддерживают не все компиляторы, популярной альтернативой является , даже несмотря на то, что она нестандартна и поэтому не включена во многие компиляторы. У нее также есть свой набор проблем. Короче говоря, если вам нужно скопировать строку в стиле C, универсального решения нет.

Еще одна полезная функция – функция , которая возвращает длину строки в стиле C (без нулевого терминатора).

В приведенном выше примере напечатается:

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

Другие полезные функции:

• – добавляет одну строку к другой (опасно);
• – добавляет одну строку к другой (с проверкой длины буфера);
• – сравнивает две строки (возвращает 0, если они равны);
• – сравнивает две строки до определенного количества символов (возвращает 0, если равны).

Вот пример программы, использующей некоторые концепции из этого урока:

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

Как вывести строку

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

Листинг 2.

#include <stdio.h>

int main(void) {
  
  char str;
  char str1 = {'Y','o','n','g','C','o','d','e','r','\0'};
  char str2 = "Hello!";
  char str3[] = "Hello!";

  for(int i = 0; i < 10; i = i + 1)
    printf("%c\t",str);
  printf("\n");

  puts(str1);
  printf("%s\n",str2);
  puts(str3);

  return 0;
}

Рис.2 Различные способы вывода строки на экран

Как видите, есть несколько основных способов вывести строку на экран.

• использовать функцию printf со спецификатором %s
• использовать функцию puts
• использовать функцию fputs, указав в качестве второго параметра стандартный поток для вывода stdout.

Единственный нюанс у функций puts и fputs

Обратите внимание, что функция puts переносит вывод на следующую строку, а функция fputs не переносит

Как видите, с выводом всё достаточно просто.

Преобразование строк

В С для преобразования строк, содержащих числа, в численные значения в библиотеке stdlib.h предусмотрен следующий набор функций:double atof(const char *string); // преобразование строки в число типа doubleint atoi(const char *string); // преобразование строки в число типа intlong int atol(const char *string); // преобразование строки в число типа long intlong long int atoll(const char *string); // преобразование строки в число типа long long int

Корректное представление вещественного числа в текстовой строке должно удовлетворять формату:

цифры]

После символов E, e указывается порядок числа. Корректное представление целого числа в текстовой строке должно удовлетворять формату:

цифры

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

float strtof(const char * restrict string, char ** restrict endptr);double strtod(const char * restrict string, char ** restrict endptr);long double strtold(const char * restrict string,char ** restrict endptr);

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

long int strtol(const char * restrict string, char ** restrict endptr, int base);unsigned long strtoul(const char * restrict string,char ** restrict endptr, int base);long long int strtoll(const char * restrict string,char ** restrict endptr, int base);unsigned long long strtoull(const char * restrict string,char ** restrict endptr, int base);

Функции обратного преобразования (численные значения в строки) в библиотеке stdlib.h присутствуют, но они не регламентированы стандартом, и рассматриваться не будут. Для преобразования численных значений в строковые наиболее удобно использовать функции sprintf и snprintf.

Ввод строк

С вводом строк всё немного сложнее, чем с выводом.
Простейшим способом будет являться следующее:

Листинг 3.

#include <stdio.h>
int main(void) {
  char str;
  gets(str); 
  puts(str);
  return 0;
}

Функция gets приостанавливает работу программы, читает строку символов, введенных с клавиатуры, и помещает в символьный массив, имя которого передаётся функции в качестве параметра.
Завершением работы функции gets будет являться символ, соответствующий клавише ввод и записываемый в строку как нулевой символ.
Заметили опасность? Если нет, то о ней вас любезно предупредит компилятор. Дело в том, что функция gets завершает работу только тогда, когда пользователь нажимает клавишу ввод. Это чревато тем, что мы можем выйти за рамки массива, в нашем случае — если введено более 20 символов.
К слову, ранее ошибки переполнения буфера считались самым распространенным типом уязвимости. Они встречаются и сейчас, но использовать их для взлома программ стало гораздо сложнее.

Итак, что мы имеем. У нас есть задача: записать строку в массив ограниченного размера. То есть, мы должны как-то контролировать количество символов, вводимых пользователем. И тут нам на помощь приходит функция fgets:

Листинг 4.

#include <stdio.h>
int main(void) {
  char str;
  fgets(str, 10, stdin);
  puts(str);
  return 0;
}

Функция fgets принимает на вход три аргумента: переменную для записи строки, размер записываемой строки и имя потока, откуда взять данные для записи в строку, в данном случае — stdin. Как вы уже знаете из 3 урока, stdin – это стандартный поток ввода данных, обычно связанный с клавиатурой. Совсем необязательно данные должны поступать именно из потока stdin, в дальнейшем эту функцию мы также будем использовать для чтения данных из файлов.

Если в ходе выполнения этой программы мы введем строку длиннее, чем 10 символов, в массив все равно будут записаны только 9 символов с начала и символ переноса строки, fgets «обрежет» строку под необходимую длину.

Обратите внимание, функция fgets считывает не 10 символов, а 9! Как мы помним, в строках последний символ зарезервирован для нуль-символа.

Давайте это проверим. Запустим программу из последнего листинга. И введём строку 1234567890. На экран выведется строка 123456789.

Рис.3 Пример работы функции fgets

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

Листинг 5.

#include <stdio.h>
int main(void) {
  char str;
  fgets(str, 10, stdin);
  puts(str);

  int h = 99;

  printf("do %d\n", h);
  scanf("%d",&h);
  printf("posle %d\n", h);

  return 0;
}

Вот результат её работы.

Рис.4 Непустой буфер stdin

Поясню произошедшее. Мы вызвали функцию fgets. Она открыла поток ввода и дождалась пока мы введём данные. Мы ввели с клавиатуры 1234567890\n(\n я обозначаю нажатие клавиша Enter). Это отправилось в поток ввода stdin. Функция fgets, как и полагается, взяла из потока ввода первые 9 символов 123456789, добавила к ним нуль-символ \0 и записала это в строку str. В потоке ввода осталось ещё 0\n.

Далее мы объявляем переменную h. Выводим её значение на экран. После чего вызываем функцию scanf. Тут-то ожидается, что мы можем что-то ввести, но т.к. в потоке ввода висит 0\n, то функция scanf воспринимает это как наш ввод, и записывается в переменную h. Далее мы выводим её на экран.

Это, конечно, не совсем такое поведение, которое мы ожидаем. Чтобы справиться с этой проблемой, необходимо очистить буфер ввода после того, как мы считали из него строку, введённую пользователем. Для этого используется специальная функция fflush. У неё всего один параметр – поток, который нужно очистить.

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

Листинг 6.

#include <stdio.h>
int main(void) {
  char str;
  fgets(str, 10, stdin);
  fflush(stdin); // очищаем поток ввода
  puts(str);

  int h = 99;
  printf("do %d\n", h);
  scanf("%d",&h);
  printf("posle %d\n", h);

  return 0;
}

Теперь программа будет работать так, как надо.

Рис.4 Сброс буфера stdin функцией fflush

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

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

На этом разговор о вводе строк закончен. Идём дальше.

3. Конвертация char и string в C++

При присвоении значения char переменной типа string, она конвертируется в string — при этом даже не нужно использовать специальные функции — это происходит автоматически. А переменные типа string ведут себя более интуитивно предсказуемо (так, как мы привыкли в других языках программирования), в следующем коде значение переменной char мы присваиваем строке и уже эту строку сравниваем с «sum»:

#include <iostream>
#include <string>
using namespace std;

int main () {
	char first_string[] = "sum";
	string real_string = first_string;
	if (real_string == "sum") {
		cout << "Строки равны!" << endl;
	}
}

В результате будет выведено:

Строки равны!

Массивы строк в С

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

Первым размером матрицы указывается количество строк в массиве, а вторым – максимальная (с учетом завершающего нуля) длина каждой строки. Например, объявление массива из пяти строк максимальной длиной 30 значащих символов будет иметь вид:

char strs;

При объявлении массивов строк можно производить инициализацию: char имя = {строковый литерал №1, … строковый литерал №N};

Число строковых литералов должно быть меньше или равно количеству строк в массиве. Если число строковых литералов меньше размера массива, то все остальные элементы инициализируются пустыми строками. Длина каждого строкового литерала должна быть строго меньше значения длины строки (для записи завершающего нуля).

Например:

char days = {    «Январь», «Февраль», «Март», ”Апрель», «Май»,    «Июнь», «Июль», «Август», «Сентябрь»,»Октябрь»,    «Ноябрь», «Декабрь»};

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

char days[] = {    «Понедельник», «Вторник», «Среда», «Четверг»,    «Пятница», «Суббота», «Воскресенье»};

Ввод и вывод строк в С

Для ввода и вывода строковой информации можно использовать функции форматированного ввода и вывода (printf и scanf). Для этого в строке формата при вводе или выводе строковой переменной необходимо указать спецификатор типа %s. Например, ввод и последующий вывод строковой переменной будет иметь вид:

char str = «»; printf(«Введите строку: «); scanf(«%30s”,str); printf(«Вы ввели: %s”,str);

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

1. перевод строки,
2. табуляция;
3. пробел.

Поэтому, используя данную функцию невозможно ввести строку, содержащую несколько слов, разделенных пробелами или табуляциями. Например, если в предыдущей программе пользователь введет строку: «Сообщение из нескольких слов», то на экране будет выведено только «Сообщение». Для ввода и вывода строк в библиотеке stdio.h содержатся специализированные функции gets и puts.

Функция gets предназначена для ввода строк и имеет следующий заголовок:char * gets(char *buffer);

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

char * fgets(char * buffer, int size, FILE * stream);

где buffer — строка для записи результата, size — максимальное количество байт, которое запишет функция fgets, stream — файловый объект для чтения данных, для чтения с клавиатуры нужно указать stdin. Эта функция читает символы со стандартного ввода, пока не считает n — 1 символ или символ конца строки, потом запишет считанные символы в строку и добавит нулевой символ. При этом функция fgets записывает в том символ конца строки в данную строку, что нужно учитывать.

Функция puts предназначена для вывода строк и имеет следующий заголовок:int puts(const char *string);

Простейшая программа: ввод и вывод строки с использованием функций fgets и puts будет иметь вид:

char str = «»; printf(«Введите строку: «);fgets(str, 102, stdin); printf(«Вы ввели: «); puts(str);

Для считывания одного символа можно использовать функцию fgetc(FILE * stream). Она считывает один символ и возвращает значение этого символа, преобразованное к типу int, если же считывание не удалось, то возвращается специальная константа EOF, равная -1. Функция возвращает значение -1 для того, чтобы можно было обрабатывать ситуацию конца файла, посимвольное чтение до конца файла можно реализовать следующим образом:

int c;while ((c = fgetc(stdin)) != EOF) {    // Обработка символа}

Для вывода одного символа можно использовать функцию  int fputc(int c, FILE *stream);.

Помимо функций ввода и вывода в потоки в библиотеке stdio.h присутствуют функции форматированного ввода и вывода в строки. Функция форматированного ввода из строки имеет следующий заголовок:

int sscanf(const char * restrict buffer, const char * restrict string, …); 

Функции форматированного вывода в строку имеют следующие заголовки:

int sprintf(char * restrict buffer, const char * restrict format, …); int snprintf(char * restrict buffer, size_t maxsize, const char * restrict format, …);