Паппас К., Мюррей У. - Visual C++ 6. Руководство разработчика - 2000

for(index = 0; index < iDAYS; index++)

cout << "siarray["<< index << "] = " << &iarray[index] << "\n"; return(0); }

Выход за пределы массива

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

/*

*norun.c

*НЕ запускайте эту программу.

*/

#include <stdio.h> #define iMAX 10

#define iOOT_OF_RANGE 50 main{)

{

int inot_enough_room[iMAX] , index;

for (index = 0; index < iOUT_OF_RANGE; index++) inot_enough_room[index] = index;

return(0);

}

Массивы символов

Хотя языки С и C++ поддерживают тип данных char, в переменных этого типа могут храниться только одиночные символы, но не строки текста. Если в программе необходимо работать со строками, их можно создавать как массивы символов. В таком массиве для каждого символа строки отводится своя ячейка, а последний элемент содержит символ конца строки — \0.

В следующем примере создаются три символьных массива. Массив szvehicle1 заполняется символ за символом с помощью оператора присваивания. Данные в массив szvehicle2 заносятся с помощью функции scanf(), а массив szvehicle3 инициализируется константной строкой.

/*

*string.с

*Эта программа на языке С демонстрирует работу с массивами символов.

*/
#include <stdio.h>
main() {	szvehiclel[7],	/* машина */
char
szvehicle2[8];		/* самолет */

static char szvehicleS[8] = "корабль"; /* корабль */

szvehiclel[0]	=	'м'
szvehiclel[1]	=	'a'
szvehiclel [2]	=	'ш'
szvehiclel[3]	=	'и'
szvehiclel[4]	=	'н'
szvehiclel[5]	=	'a'
szvehiclel[6]	=	'\0';

printf ("\n\n\tВведите слово -—> самолет ") ; scanf("%s",szvehicle2);

141

printf("%s\n",szvehiclel);

printf("%s\n",szvehicle2);

printf("%s\n",szvehicle3);

return(0);

}

Хотя слово "машина", сохраненное в массиве szvehiclel, состоит из шести букв, массив содержит семь элементов: по одному для каждой буквы плюс еще один для символа конца строки. То же самое справедливо и для других двух массивов. Вспомните также, что массив szvehicle3 можно задать путем указания последовательности символов в фигурных скобках:

static char szvehicleS[8]= {'к','о','р','а','б','л','ь','\0'};

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

static char szvehicleS[] = "корабль";

При этом размер массива определяется компилятором автоматически.

Часто содержимое массива запрашивается у пользователя с помощью функции scanf( ) , как в случае с массивом szvehicle2. В нашем примере в функции scanf( ) применяется спецификация %s,означающая ввод строки. В результате функция пропустит ведущие пробельные литеры (символы пробела, табуляции и конца абзаца), после чего; запишет в массив последовательность символов вплоть до следующей пробельной литеры. В завершение к набору символов будет автоматически добавлен символ конца строки. Помните, что при объявлении массива следует указать такой размер, чтобы в массиве поместился весь вводимый текст вместе с символом \0.

Рассмотрим еще раз строку программы, в которой в массив szvehicle2 записывается информация:

scanf ("%s",szvehicle2);

Не удивил ли вас тот факт, что имени szvehicle2 не предшествует оператор взятия адреса &? Это объясняется тем, что имя массива, в отличие от имен других переменных, уже является адресом первого его элемента.

Когда в функции printf ( ) задана спецификация %s, то предполагается наличие аргумента также в виде адреса строки. Строка текста будет выведена на экран полностью, за исключением завершающего нулевого символа.

Ниже показана программа на языке C++, аналогичная рассмотренной выше:

//

//string. срр

//Это версия предыдущей программы на языке C++.

#include <iostream.h> main () {

char szvehiclel	[7],	// машина
szvehicle2 [8];	// самолет

static char szvehicleS[8] = "корабль"; // корабль

szvehiclel[0]		=	'м'
szvehiclel[1]	=		'a'
szvehiclel[2]	=		'ш'
szvehiclel[3]	=		'и'
szvehiclel[4]	=		'н'
szvehiclel[5]	=		'a'
szvehiclel[6]	=		'\0';
cout<< "\n\n\tВведите		слово --> самолет ";
cin >> szvehicle2;
cout << szvehiclel <<		"\n";
cout << szvehicle2 <<		"\n";

142

cout << szvehicleS << "\n"; return(0);

}

При выполнении любой из приведенных программ на экран будет выведено следующее:

машина

самолет

корабль

Многомерные массивы

Под размерностью массива понимают число индексов, которые необходимо указать для получения доступа к отдельному элементу массива. Все массивы, рассмотренные до сих пор, были одномерными и требовали указания только одного индекса. Чтобы определить размерность массива, достаточно посмотреть на его объявление. Если в нем указана только одна пара квадратных скобок ([]), то перед нами одномерный массив, если две ([][]), то двухмерный, и т.д. Массивы с более чем одной размерностью называются многомерными. В реальных программах размерность массива не превышает трех.

В следующей программе создается двухмерный массив:

/*

*2darray.c

*Эта программа на языке С демонстрирует работу с двухмерным массивом.

*/

#include <stdio.h> #define iROWS 4 #define iCOLUMNS 5 main() {

int irow; int icolumn;

int istatus [iROWS] [iCOLUMNS] ; int iadd;

int imultiple;

for (irow = 0; irow < iROWS; irow++)

for (icolumn = 0; icolumn < iCOLUMNS; icolumn++)

{ iadd = iCOLUMNS - icolumn; imultiple = irow; istatus [irow][icolumn]

=

(irow+1) *icolumn +

iadd*imultiple;

}

for(irow = 0; irow < iROWS; irow++)

{ printf("ТЕКУЩАЯ СТРОКА: %d\n", irow); printf("СМЕЩЕНИЕ ОТ НАЧАЛА МАССИВА:\n"); for(icolumn = 0; icolumn < iCOLUMNS; icolumn++)

printf(" %d ", istatus[irow][icolumn]); printf("\n\n");

}

return(0);}

В программе используются два цикла for, в которых каждый элемент массива инициализируется значением смещения этого элемента относительно первой ячейки массива. Созданный массив имеет 4 строки (константа irows) и 5 столбцов (константа icolumns), что в сумме дает 20 элементов. Многомерные массивы представляются в памяти компьютера в виде линейной последовательности элементов, при этом группировка по индексам осуществляется справа налево, т.е. от самого правого индекса к самому левому.

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

istatus[irow][icolumn] = ...

143

В результате выполнения программы на экран будет выведена следующая информация: ТЕКУЩАЯ СТРОКА: 0 СМЕЩЕНИЕ ОТ НАЧАЛА МАССИВА: 01234 ТЕКУЩАЯ СТРОКА: 1 СМЕЩЕНИЕ ОТ НАЧАЛА МАССИВА: 56789 ТЕКУЩАЯ СТРОКА: 2 СМЕЩЕНИЕ ОТ НАЧАЛА МАССИВА: 10 11 12 13 14 ТЕКУЩАЯ СТРОКА: 3 СМЕЩЕНИЕ ОТ НАЧАЛА МАССИВА: 15 16 17 18 19

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

/*

*2dinit.c

*Эта программа на языке С демонстрирует инициализацию двухмерного массива.

*/
#include <stdio.h>
#include <raath.h>
#define	iBASES 6
#define	iEXPONENTS 3
#define	iBASE 0
#define	iRAISED_TO 1
#define	iRESULT 2
main ()	{
double dpowers[iBASES][iEXPONENTS] = {
1,1,1,0,
2,2,2,0,
3,3,3,0,
4,4,4,0,
5,5,5,0,
6,6,6,0,

};

int irow_index;

for(irow_index = 0; irow_index < iBASES; irow_index++)

dpowers [irowjmdex] [iFESOLT] = pow(dpowers[irow_index] [1BASE], dpowers [irow_index] [iRAISED_TO,] ) ;

for(irow_index = 0; irow_index < iBASES; irow_index++) { printf(" %d\n", (int) dpowers[irow_index][iRAISEDJTO]); printf("%2.1f= %.2f\n\n",dpowers[irow_index][iBASE], dpowers[irow_index][iRESULT]) ,

}

return(0); }

Библиотечная функция pow(x,у) возводит х в степень у. Массив dpowers имеет тип double, поскольку данная функция работает с числами этого типа. В первом столбце массива записаны числа, возводимые в степень, во втором столбце — показатели степени, в третий столбец помещается результат.

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

1 1.1= 1.10

2 2.2= 4.84

3 3.3= 35.94

4 4.4= 374.81

5 5.5= 5032.84

6 6.6= 82653.95

Массивы как аргументы функций

144

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

Передача массивов функциям в языке С

Предположим, имеется функция isum(), которая подсчитывает сумму элементов массива inumeric_values, содержащего целые числа. Для работы функции необходимы два аргумента: указатель iarray_address_received, принимающий копию адреса массива, и переменная imax_size, содержащая индекс последнего элемента, участвующего в операции суммирования. Тогда заголовок функции isum()будет записан следующим образом:

int isumfint iarray_address_received[], int imax_size)

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

isum(inumeric_values, iactual_index);

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

itotal = isum(Sinumeric_values[0], iactual_index);

Вотличие от переменных, которые могут передаваться в функцию по значению (т.е. внутри функции создается локальная копия переменной), массивы всегда передаются по ссылке, и в вычислениях участвуют реальные элементы массива, а не их копии. Это предупреждает появление сообщений вида "stack overruns heap" (стек перегружен), которые постоянно беспокоят программистов на языке Pascal, если они забывают при описании формальных аргументов указывать перед именами массивов модификатор var. В этом случае массивы передаются по значению, что заставляет компилятор дублировать их содержимое. При работе с большими массивами этот процесс может потребовать много времени и свободной памяти.

Вследующем примере создается массив из пяти элементов, а функция iminimum() определяет наименьший из них. С этой целью в функцию iminimum. Oпередаются имя массива и число сравниваемых элементов — в данном случае это весь массив (указана константа 1МАХ).

/*

*arrayarg.c

*Эта программа на языке С демонстрирует передачу массива в качестве

*аргумента функции.

*/

#include <stdio.h> #define iMAX 10

int iminimum(int iarrayU,int imax); main()

int iarraytiMAX[] = {3, 7, 2, 1, 5, 6, 8, 9, 0, 4}; int i, ismallest;

printf("Вот элементы массива: "); for(i = 0; i < iMAX; i++) printf("%d", iarray[i]); ismallest = iminimumdarray, iMAX);

printf("\nМинимальное значение: %d\n",ismallest); return(0); }

int iminimum(int iarrayt[],int imax) int i, icurrent_minimum;

icurrent_minimum = iarray[0]; for(i= 1; i < imax; i++) if(iarrayti]< icurrent_minimum) icurrent_minimum = iarray[i]; return(icurrent minimum);

}

Передача массивов функциям в языке C++

Следующая программа на языке C++ также содержит пример передачи массива в функцию.

145

//

//arrayarg.cpp

//Эта программа на языке C++ демонстрирует передачу массива в качестве

//аргумента функции.

//

#include <iostream.h> #define iSIZE 5

void vadd_l (int iarray[]); main() {

int iarray[iSIZE] = {0,1, 2, 3, 4 } ;

int i;	"Массив			iarray перед вызовом функции vadd_l:\n\n";
cout <<
for(i	=	0;	i	< iSIZE;	i++)
cout <<	"	"	<< iarray[i];
vadd_l(iarray);
cout << "\n\nМассив iarray после вызова функции vadd_l:\n\n";
for(i	=0;	i	<	iSIZE;	i++)
cout <<	"	"	<<	iarray[i];

return(0); }

void vadd_l(int iarray[]) { int i;

for(i =0;i < iSIZE; i++) iarray [i]++; }

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

Массив iarray перед вызовом функции vadd_l: 0 1 2 3 4

Массив iarray после вызова функции vadd_l: 1 2 3 4 5

Результаты работы программы дают четкий ответ на вопрос о том, каким способом массив передается в функцию: по значению или по ссылке. Функция vadd_l() добавляет единицу к каждому элементу массива. Так как это действие отражается на массиве iarray в функции main(), можно сделать вывод, что аргумент передается по ссылке.

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

//

//3darray.cpp

//Эта программа на языке C++ демонстрирует, как создавать многомерный

//массив, передавать его в функцию и выбирать отдельный элемент

//такого массива.

//

#include <iostream.h>

void vdisplay_results(char carray[][3][4]); char cglobal_cube[5][4][5]= { { {'Т','А','В','L','Е'},

{'Z','Е','R','О',' '}, {' ',' ',' ',' ',' '), {'R','О','W,' ', '3'}, },

146

{
('Т','А','В','L','Е'},
{'О','N','Е',' ',' '},
{'R','О','W',' ','2'},
},
{
{'Т','А','В','L','Е'},
{'Т','W','О',' ',' '},
},
{
{'Т','А','В','L','Е'),
{'Т','Н','R','Е','Е'),
{'R','О','W',' ','2'},
{'R','О','W',' ','3'),
},
{
('Т','А','В','L','E'},
('F','О','U','R',' '},
('r','о','w',' ','2'},
{'а','b','с','d','е'},
} };
int imatrix[4][3]={ {1},{2},{3},(4} };
main () {
int irow_index, icolumn_index;
char clocal_cube[2] [3][4];
cout<<	"Размер массива clocal_cube	= "

<<sizeof(clocal_cube) << "\n";

cout <<

"Размер таблицы clocal_cube[0]

= "

<<sizeof (clocal_cube[0]) << "\n";

cout<<

"Размер строки clocal_cube[0][0]

= "

<<sizeof(clocal_eube[0][0]) << "\n";

cout	<<	"Размер элемента clocal_cube[0][0][0] = "
<<	sizeof(clocal_cube[0][0][0]) << "\n";
vdisplay_results(clocal_cube);
cout	<< "Элемент cglobal_cube[0][1][2] = " << cglobal_cube[0][1][2] <<
"\n";	<< "Элемент cglobal__cube [1][0][2]= " << cglobal_cube[l][0][2]
cout
<< "\n";		"\nВывод фрагмента массива cglobal_cube				(таблица		0)\n";
cout	<<
for (irow_index = .0; . irow_index < 4;				irow_index++)			(
for(icolumn_index = 0;			icolumn_index <	5;	icolumn_index++) cout
<< cglobal_cube[0][irow_index][icolumn_index];
cout	<<	"\n"; }
cout	<<	"\nВывод фрагмента массива cglobal_cube				(таблица		4)\n";

for(irow_index = 0; irow_index < 4; irow_index++) {

for(icolumn__index = 0; icolumn_index < 5; icolumn_index++) cout << cglobal_cube[4][irow_index][icolumn_index];

cout << "\n"; )

cout << "\nВывод всего массива imatrix\n";

for (irow_index = 0; irow_index .< 4; irow_index++) {

for(icolumn_index =0;icolumn_index < 3; icolumn_index++) cout << imatrix[irow_index][icoluran_index];

cout << "\n"; } return(0); }

void vdisplay_results(char carray[][3][4])

147

{
cout << "Размер массива carray	= " <<	sizeof(carray) <<
"\n";
cout << "Размер таблицы carray[0]	= " <<	sizeof(carray[0]) <<
"\n";	= " <<	sizeof(cglobal_cube)
cout << "Размер массива cglobal_cube
<< "\n";

cout << "Размер таблицы cglobal_cube[0]= " << sizeof(cglobal_cube[0]) << "\n";

}

Прежде всего обратите внимание на то, как объявляется и инициализируется массив cglobal_cube. Фигурные скобки используются для выделения групп символов, относящихся к одной размерности массива. Такой подход облегчает работу по заполнению массива данными, так как позволяет четко визуализировать его форму. А в принципе, в фигурных скобках нет необходимости: все элементы можно записать и в один ряд. Разбиение списка элементов на блоки особенно полезно в тех случаях, когда отдельные элементы следует оставить незаполненными. В нашем случае для большей наглядности трехмерный массив лучше всего сгруппировать в пять блоков, каждый из которых представляет собой таблицу из четырех строк и пяти столбцов.

В процессе выполнения программы на экран будут сначала выведены четыре строки с описанием размера всего массива clocal_cube, одной его таблицы, строки и отдельного элемента. Эти значения помогут вам лучше представить, из чего складывается размер массива. К примеру, размер трехмерного массива можно вычислить как произведение размеров трех его составляющих, умноженное на размер одного элемента. В нашем случае размер массива clocal_cubeбудет равен 2*3*4*sizeof(char) = 24.

Обратите внимание на то, что часть массива clocal_cube[0]сама является двухмерным массивом 3x4, то есть ее размер составляет 12. Размер строки clocal_cube[0][0]равен 4, что соответствует числу элементов в ней, так как размер одного элемента равен 1 (sizeof(clocal_cube[0] [0][0])).

Чтобы полностью разобраться с многомерными массивами, следует четко уяснить, что выражение clocal_cube[ 0 ] является константным указателем. В программе не объявлен массив clocal_cube[ 0 ] — на самом деле это последнее измерение многомерного массива clocal_cube. Выражение clocal_cube[0 ] не ссылается ни на один конкретный элемент массива, а лишь указывает на обособленный его фрагмент, поэтому тип данного выражения не char, а константный указатель на char, который не может выступать адресным операндом, то есть стоять слева от оператора присваивания.

Интересные события происходят, когда имя массива clocal_cubeпередается в качестве аргумента функции vdisplay_results(). В теле функции оператор sizeof не сможет правильно определить размер параметра carray, так как функция получает только копию адреса первого элемента массива, поэтому оператор вернет размер этого адреса (4 байта), а не самого массива и даже не его первого элемента. В то же время, размер фрагмента саггау[0]будет вычислен правильно — 3x4=12, поскольку в заголовке функции указано, что первый параметр является массивом, две последние размерности которого равны 3 и 4.

Функция vdisplay_results() выводит также размер глобального массива cglobal_cube, причем вычисляет его правильно. На этом примере мы видим, что из тела функции можно получать непосредственный доступ к глобальному массиву, но если массив передается в качестве аргумента, то функции доступен только его адрес.

Две строки в теле программы, следующие за вызовом функции vdisplay_results() , демонстрируют возможность обращения к отдельным элементам многомерного массива cglobal_cube. Выражение cglobal_cube[0] [1] [2] возвращает значение элемента нулевой (первой по порядку) таблицы, второй строки и третьего столбца — 'R'. Выражение cglobal_cube[l] [0][2]ссылается на элемент второй по порядку таблицы, первой ее строки и третьего столбца — 'В'.

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

148

выводится содержимое пятой таблицы массива cglobal_cube. В конце отображается содержимое массива imatrix в виде таблицы; именно так большинство из нас и представляет себе двухмерный массив.

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

Размер массива clocal_cube	=	24
Размер таблицы clocal_cube[0]	=	12
Размер строки clocal_cube[0][0]	=	4
Размер элемента clocal_cube[0][0][0]= 1
Размер массива саггау	= 4
Размер таблицы саггау[0]	= 12	= 100
Размер массива cglobal_cube
Размер таблицы cglobal_cube[0]		= 20
Элемент cglobal_cube[0][1][2]	= В	= R
Элементcglobal_cube[1][0][2]

Вывод фрагмента массива cglobal_cube (таблица 0)

TABLE

ZERO

ROW 3

Вывод фрагмента массива cglobal_cube(таблица 4)

TABLE FOUR row 2 abed

Вывод всего массива imatrix

100

200

300

400

Вас удивила последняя часть? Тогда рассмотрим инициализацию массива imatrix. Каждая внутренняя пара фигурных скобок соответствует новой строке массива, но, поскольку внутри скобок указано меньше значений, чем размер строки, отсутствующие элементы массива остаются нулевыми. Вспомните, что в C/C++ все неинициализированные элементы статического массива по умолчанию автоматически становятся равными нулю.

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

Многие функции работы со строками принимают в качестве аргумента имя массива символов: gets(),putsО, fgetsO,fputsO, sprintfO, strcpyO, strcat(), strncmp() и strlen(). Настало время познакомиться с ними. Сейчас вам будет значительно проще понять принципы их работы, поскольку вы уже изучили основные концепции создания массивов.

Функцииgets( ), puts( ), fgets( ), fputs( ) иsprintf( )

В следующей программе показано, как с помощью функций gets(), puts (), fgets(), fputs() и sprintf() можно управлять процессом ввода/вывода строк:

/*

*stringio.c

*Эта программа на языке С демонстрирует применение функций работы со строками.

*/

#include <stdio.h> #define iSIZE 20 main()

{

149

char sztest_array[iSIZE];
fputs("Введите	первую строку	: ", stdout); gets(sztest_afray);
fputs("Выввели	: ", stdout);
puts(sztest_array) ;
fputs("Введите	вторую строку		: ", stdout);
fgets(sztest_array, iSIZE, stdin);
fputs("Выввели	: ", stdout);
fputs(sztest_array, stdout);			.
sprintf(sztest_array, "Это была %s проверка", "только");
fputs("Функция	sprintf() создала : ", stdout);
fputs(sztest_array, stdout);
return(0); }
Вот что будет выведено на экран в результате работы программы:
Введите первую	строку:		строка один
Вы ввели	:		строка один
Введите вторую	строку:		строка два
Вы ввели	:	:	строка два
Функция sprintf() создала			Это была только проверка

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

Функция gets() принимает символы от стандартного устройства ввода (в большинстве случаев это клавиатура) и помещает их в массив, указанный в качестве аргумента. Когда вы нажимаете клавишу [Enter] для завершения ввода, генерируется символ новой строки (\n). Функция gets() преобразует его в нулевой символ (\0), который служит признаком конца строки. Учтите, что при использовании функции gets() нет возможности напрямую определить, превышает ли количество введенных символов размер массива.

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

Функция fgets()'аналогична функции gets(), но позволяет контролировать соответствие числа введенных символов установленным размерам массива. Символы читаются из указанного потока, которым может быть файл или, как в данном случае, стандартное устройство ввода (stdin). Введенных символов должно быть на единицу меньше, чем размер массива: в последнюю позицию автоматически добавляется нулевой символ. Если был введен символ новой строки, то он сохранится в массиве непосредственно перед символом \ 0. По аналогии с работающими в паре функциями gets() и puts(), совместно с функцией fgets() используют функцию fputs().

Поскольку первая не удаляет символы новой строки, то и вторая не добавляет их. Функция fputs() направляет символы в указанный поток: файл или устройство стандартного вывода stdout(как правило, это консоль).

Имя функции sprintf() является сокращением от слов "string printf()", т.е. "строковая функция printf()". В этой функции используются те же спецификаторы форматирования, что и в printf().Основное отличие состоит в том, что функция sprintf() помещает результат не на экран, а в указанный массив символов. Это может быть полезно, если результат работы данной функции необходимо вывести несколько раз, скажем, на экран и на принтер.

Функции strcpy( ), strcat( ), strncmp( ) и strlen( )

Все функции, рассматриваемые в этом параграфе, объявлены в файле STRING.H. Для их работы требуется, чтобы передаваемые им наборы символов обязательно заканчивались признаком конца строки — символом \0. В следующей программе демонстрируется использование функции strcpy() :

/*

*strcpy.с

150