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

intmain() {

vsmallest("Выводим %dцелых чисел, %d %d %d",10,4, 1); return (0); }

void vsmallest (char *szmessage, ...)

{

int inumber_of_percent_ds = 0; va_listtype_for_ellipsis;

int ipercent_d_format = 'd'; char *pchar;

pchar = strchr (szmessage, ipercent_d_format) ; while (*++pchar != '\0'){ pchar++;

pchar = strchr (pchar, ipercent_d_format) ; inumber_of_percent_ds++;

}

printf{"Выводим%d целых чисел,",inumber_pf percent_ds) ; va_start(type_for_ellipsis, szmessage); while(inumber_of_percent_ds--)

printf(" %d", va_arg(type_for_ellipsis, int)); va_end(type_for_ellipsis); }

Функция vsmallest() ожидает двух формальных аргументов: указателя на строку и списка неопределенной длины. Естественно, функция должна иметь возможность каким-то образом определить, сколько же аргументов она получила на самом деле. В данной программе эта информация передается в строковом аргументе.

Созданная нами функция vsmallest() частично имитирует работу стандартной функции printf (). Аргумент szmessage рассматривается как строка форматирования, в которой подсчитывается число спецификаций %d. Полученная информация позволяет вычислить количество дополнительных аргументов.

Функция strchr() возвращает адрес позиции спецификатора d в строке форматирования. Первый элемент %d игнорируется, поскольку на его месте будет выведено общее число аргументов. В первом цикле while определяется количество спецификаторов d в строке szmessage, и полученное значение заносится в переменную inumber_of_percent_ds. По завершении цикла на экран выводится первая часть сообщения.

Макрос va_start() устанавливает указатель type_for_ellipsis(обратите внимание на его тип — va_list) в начало списка аргументов функции. Второй параметр макроса является именем обязательного аргумента анализируемой функции, который стоит непосредственно перед многоточием. Макрос va_arg() возвращает очередной аргумент из списка. Второй параметр макроса указывает на тип возвращаемого аргумента (в нашей программе это тип int). Макрос va_end() очищает указатель type_for_ellipsis, делая его равным нулю.

Область видимости переменных

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

Попытка получить доступ к переменной вне ее области видимости

В следующем примере в функции main() объявляются четыре локальные переменные. В программе как будто бы нет никаких ошибок. Тем не менее, когда функция iproduct() попытается обратиться к переменной in, она не сможет ее обнаружить. Почему? Потому что область видимости этой переменной ограничена только функцией main().

/*

*scope.с

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

131

*определения области видимости переменной. Во время компиляции

*программы появится сообщение об ошибке.

*/

#include <stdio.h>

int iproduct(int iw, int ix); int main () {

int il = 3; int im = 7; int in = 10; int io;

io = iproductfil, im) ;

printf("Произведение чисел равно %d\n",io) ; return(0); }

int iproduct (int iw, int ix)

{

int iy;

iy = iw * ix * in; return (iy); }

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

В следующем примере переменная inописана как глобальная. В результате обе функции, как main(),так и iproduct(),могут использовать ее. Обратите также внимание на то, что и та, и другая функция может изменить значение переменной in.

/*

*fscope.с

*Это исправленная версия предыдущей программы. Проблема решена путем

*объявления переменной in как глобальной.

*/

#include <stdio.h>

int iproduct (int iw, int ix) ; int in = 10; int main() (

int il = 3; int im = 7; int io;

io = iproduct (il,im) ;

printf("Произведение чисел равно %d\n",io) ; return (0);

}

int iproduct(int iw, int ix) int iy;

iy = iw * ix * in; return(iy);

Эта программа будет корректно скомпилирована, и на экране появится результат - 210.

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

/*

*Isсоре.с

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

*между одноименными локальной и глобальной переменными.

*Функция iproduct() находит произведение трех переменных,

132

*из которых две передаются как аргументы функции, а еще

*одна, in,объявлена и как глобальная, и как1 локальная.

*/

#include <stdio.h>

int iproduct(int iw, int ix); int in = 10;

int main()

int il = 3; int im = 7; int io;

io = iproduct(il,im) ;

printf("Произведение чисел равно %d\n",io) ; return (0);

int iproduct(int iw, int ix) { int iy;

int in = 2;

iy = iw * ix * in; return(iy); }

В этом примере переменная inописывается дважды: на уровне файла и на уровне функции. В функции iproduct(), где эта переменная объявлена как локальная, будет использовано "локальное" значение. Поэтому результатом умножения будет 3*7*2 = 42.

Оператор расширения области видимости

В следующей программе, написанной на языке C++, все работает нормально до момента вывода информации на экран. Объект cout правильно отобразит значения переменных 11 и im, но для переменной inбудет выбрано "глобальное" значение. Вследствие этого пользователю будет представлен неправильный результат: "3*7*10= 42". Как вы уже поняли, ошибка возникает из-за того, что в функции iproduct() используется локальная переменная in.

//

//scopel.срр

//Эта программа на языке C++ содержит логическую ошибку.

//Функция iproduct() находит произведение трех переменных,

//используя при этом значение локальной переменной in.

//В то же время в выводимых данных программа сообщает

//о том, что значение переменной inравно 10.

//

#include <iostream.h>

int iproduct (int iw, int ix); int in = 10;

int main()

{

int 11 = 3; int im = 7 ; int io;

io = iproduct (il,im) ;

cout << il << " * " << im << " * " << in << " = " << io << "\n"; return (0);

}

int iproduct(int iw, int ix) { int iy; int in = 2;

iy = iw * ix * in; return (iy);}

Что же нужно сделать, чтобы получить правильный результат? Для этого достаточно воспользоваться оператором расширения области видимости (::), о котором мы уже упоминали:

iy = iw * ix * ::in;

133

Следующая программа иллюстрирует сказанное.

//

//scope2.cpp

//Это исправленная версия предыдущего примера. Проблема решена путем

//использования оператора расширения области видимости (::).

//

#include <iostream.h>

int iproduct(intiw, int ix) ; int in = 10; int main ()

int il = 3; int im = 7; int io; io = iproduct(il,im) ;

cout << il << " * " << im << " * " << in << " = " << io << "\n"; return (0);

}

int iproduct(intiw, int ix) int iy;

int in = 2;

iy = iw * ix * (::in); return(iy);}

Переменная in вместе с оператором :: для наглядности взяты в скобки, хотя в этом нет необходимости, так как данный оператор имеет самый высокий приоритет среди остальных. Таким образом, на экран будет выведен правильный результат: "3*7*10 = 210".

134

Глава 8. Массивы

•Что такое массивы

•Свойства массивов

•Объявления массивов

•Инициализация массивов

o Инициализация по умолчанию o Явная инициализация

oИнициализация безразмерных массивов

•Доступ к элементам массива

•Вычисление размера массива в байтах

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

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

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

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

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

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

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

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

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

Вэтой главе вы узнаете, как создавать массивы данных и работать с ними. В C/C++ темы массивов, указателей и строк взаимосвязаны, во многих книгах они даже рассматриваются в одной главе. С нашей точки зрения, это не лучший подход, поскольку часто для работы с массивами не требуется глубокого знания указателей. Кроме того, с массивами в целом связан достаточно большой объем материала, и параллельное изучение указателей может совершенно запутать дело. В то же время, без уяснения принципов использования указателей вы не сможете полноценно работать с массивами. Поэтому главу "Указатели" можно рассматривать как завершение дискуссии о массивах.

Что такое массивы

Массив можно представить как переменную, содержащую упорядоченный набор данных одного типа. К каждому элементу массива можно получить доступ по его адресу. В языках C/C++ массив не является стандартным типом данных. Напротив, он сам имеет тип: char, int, float, doubleи т.д. Допускается создавать массивы массивов, указателей, структур и др. Принципы построения массивов и работы с ними в основе своей одинаковы в С и C++.

Свойства массивов

Ниже перечислены четыре основных принципа, определяющих свойства массивов: в массиве хранятся отдельные значения, которые называются элементами;

•все элементы массива должны быть одного типа;

135

•все элементы массива сохраняются в памяти последовательно, и первый элемент имеет нулевое смещение адреса, т.е. нулевой индекс;

•имя массива является константой и содержит адрес первого элемента массива.

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

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

Объявления массивов

Ниже даны примеры объявления массивов:

intiarray[12]; /* массив из двенадцати целых чисел */ charcarray[20]; /* массив из двадцати символов */

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

Вот как устанавливаются размеры массивов с помощью констант:

#define iARRAY_MAX 20 #define fARRAY_MAX 15

int iarray[iARRAY_MAX]; char farray[fARRAY_MAX];

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

#include <stdio.h> #define iARRAY_MAX 20 int iarray[iARRAY_MAX]; main (} {

int i;

for(i= 0; i < iARRAY_MAX; i++) {

}

return(-0); }

Инициализация массивов

Массив можно инициализировать одним из трех способов:

•при создании массива — используя инициализацию по умолчанию (этот метод применяется только для глобальных и статических массивов);

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

•в процессе выполнения программы — путем записи данных в массив.

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

136

Инициализация по умолчанию

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

/*

.* initar.c

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

*выполняемую по умолчанию.

static int istatic_array[iSTATIC_ARRAY_SIZE]; /* статический массив */ int i;

for (i = 0; i < iGLOBAL_ARRAY_SIZE; i++)

printf ("iglobal_array [%d].:%d\n",i, iglobal_array [i] )

;

for(i= 0; i < iSTATIC_ARRAY_SIZE; i++) printf("istatic_array[%d]: %d\n", i, istatic_array[i]);

return(0); }

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

Явная инициализация

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

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

Втретьей строке показан пример задания большего числа элементов массива, чем в нем на самом деле содержится. Многие компиляторы рассматривают подобную ситуацию как ошибку, тогда как другие автоматически увеличивают размер массива, чтобы вместить дополнительные элементы. Компилятор MicrosoftVisualC++ выдаст ошибку вида "too many initializers" (слишком много инициализаторов). В противоположной ситуации, когда при инициализации указано меньше значений, чем элементов массива, оставшиеся элементы по умолчанию примут нулевые значения. С учетом этого можно вообще не задавать размер массива, как в четвертой строке программы. Количество значений, указанных в фигурных скобках, автоматически определит размер массива.

Инициализация безразмерных массивов

137

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

Здесь необходимо предварительно подсчитать число символов в строке, не забыв к полученному числу прибавить 1 для символа \0,обозначающего конец строки. Это нудная работа, к тому же чреватая ошибками. Можно позволить компилятору автоматически вычислить размер массива, как показано ниже:

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

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

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

int iweekend;

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

int iweek[7] ;

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

iweek[0];

iweek[1];

iweek[2];

iweek[3];

.

.

.

iweek[6];

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

Начинающие программисты часто допускают ошибку, считая, что первый элемент имеет индекс 1. Для обращения к первому элементу массива следует указывать индекс 0, так как смещение первого элемента относительно самого себя, естественно, является нулевым. А например, к третьему элементу следует обращаться по индексу 2, так как он на две ячейки смещен по отношению к первому элементу.

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

138

int iweek[7];

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

iweek[3];

Для описанного выше массива iweek следующее выражение присваивания является неправильным:

iweek[7] = 53219;

В массиве iweek нет элемента со смещением 7 по отношению к первому элементу, другими словами — восьмого элемента. Поскольку массив содержит только семь элементов, данная строка вызовет ошибку. Вы как программист ответственны за то, чтобы индексы в обращениях к массиву имели допустимое значение.

Рассмотрим следующие объявления массива, переменных и константы:

#define iDAYS_OF_WEEK 7 int iweek[iDAYS_OF_WEEK]; int iweekend = 1;

int iweekday = 2;

и выражения:

iweek[2]; iweek[iweekday] ;

iweek[iweekend + iweekday]; iweek[iweekday - iweekend]; iweek[iweekend - iweekday];

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

Для того чтобы получить доступ к элементу массива, нет необходимости учитывать размер занимаемой им памяти, так как подобная работа выполняется компилятором автоматически. Предположим, например, что вам нужно получить значение третьего элемента массива iweek, содержащего целые числа. Как было сказано в главе "Работа с данными", в различных системах для представления данных типа int могут использоваться ячейки памяти разных размеров: иногда 2 байта, иногда 4. Но независимо от системы вы в любом случае сможете получить доступ к третьему элементу массива, используя выражение iweek[ 2 ]. Индекс указывает на порядковый номер элемента в массиве вне зависимости от того, сколько байтов занимает каждый элемент.

Вычисление размера массива в байтах

Вам уже известен оператор sizeof, возвращающий размер указанного операнда в байтах. Этот оператор можно использовать с переменными любых типов, за исключением битовых полей. Часто оператор sizeof применяют, чтобы определить размер переменной, тип которой в разных системах может иметь разную размерность. Как говорилось выше, в одном случае для представления целочисленного значения отводится 2 байта, в другом — 4 байта. Поэтому, например, при работе с массивами, размещаемыми в памяти динамически, необходимо точно знать, сколько памяти запрашивать у операционной системы. Следующая программа автоматически вычислит и отобразит на экране число байтов, занимаемых массивом из семи целочисленных элементов:

/*

*sizeof.с

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

*оператора sizeofдля определения физического размера массива.

*/

#include <stdio.h>

139

#define iDAY_OF_WEEK 7 main () {

int iweek[iDAY_OF_WEEK] = (1,2, 3, 4, 5, 6, 7} ; printf("Массив iweek занимает%d байт.\n",(int) sizeof(iweek)); return(0);.

}

Вы можете спросить, почему значение, возвращаемое оператором sizeof, приводится к типу int. Дело в том, что в соответствии со стандартом ANSI данный оператор возвращает значение типа size_t, поскольку в некоторых системах одного лишь типа int оказывается недостаточно для представления размерностей данных некоторых типов. В нашем примере операция приведения необходима также для того, чтобы выводимое число соответствовало спецификации %d функции printf().

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

/*

*array.с

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

*в смежном размещении в памяти элементов массива.

*/

#include <stdio.h> #define iDAYS 7 main ()

{

int index, iarray[iDAYS];

printf("sizeof(int)= %d\n\n",(int)sizeof(int)); for(index = 0; index < iDAYS; index++) printf("siarray[%d]= %X\n",index, &iarray[index]); return(0); }

Запустив программу, вы получите примерно следующий результат: sizeof(int)= 4

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

Ниже показан аналог этой же программы на языке C++:

//

//array.срр

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

#include <iostream.h> #define iDAYS 7

main () {

int index, iarray[iDAYS];

cout << "sizeof (int) = " << (int)sizeof(int) << "\n\n";

140