Реферат: Лекции по C++

/* default storage class is auto */

                                    int c = 0;

/* values printed are 1, 0, 0, 0 */ printf("%d\n%d\n%d\n%d\n", i, a, b, c);

                                    other();

                 }

                 other()

                 {

                                    /* i is redefined */

                                    int i = 16;

                                    /* this a is visible only within other */

                                    static int a = 2;

                                    a += 2;

/* values printed are 16, 4 */

                                    printf("%d\n%d\n", i, a);

                 }

               Переменная i определяется на внешнем уровне с инициализаци­ей  1.  В  функции  main  об"явлена ссылка extern на переменную i внешнего уровня. Переменная класса  памяти  static  автоматически

устанавливается  в 0, так как инициализатор опущен. Вызов функции print (предполагается, что функция print  определена  в  каком-то месте исходной программы.) печатает величины 1, 0, 0, 0.

               В  функции other, переменная i переопределяется как локаль­ная переменная с начальным значением 16. Это не влияет на  значе­ние внешней переменной i. Переменная a об"является как переменная класса памяти static с начальным значением 2. Она не противоречит переменной a, об"явленной в функции main, так как видимость пере­менных  класса памяти static на внутреннем уровне ограничена бло­ком, в котором она об"явлена.

               Значение переменной увеличивается на 2 и становится  равным 4.  Если бы функция other была вызвана снова в той же самой прог­рамме, то начальное значение a стало бы равным 4. Внутренние  пе­ременные  класса памяти static сохраняют свои значения, когда за­канчивается выполнение блока, в котором они об"явлены.

     Об"явление функции на внешнем и внутреннем уровнях

               Функции могут быть об"явлены со спецификаторами класса  па­мяти  static  или  extern.  Функции всегда имеют глобальное время жизни.

               Правила видимости для функций отличаются от правил видимос­ти для переменных. Об"явления функций на внутреннем уровне  имеют тот  же самый смысл, что и об"явления на внешнем уровне. Это зна­чит, что функции не могут иметь  блочной  видимости  и  видимость функций  не может быть вложенной. Функция об"явленная как static,

видима только в пределах исходного файла, в котором она определя­ется. Любая функция в том же самом исходном файле  может  вызвать функцию  static,  но функции static из других файлов нет. Функция static с тем же самым именем может быть об"явлена в другом исход­ном файле.

               Функции, об"явленные как extern видимы в пределах всех  ис­ходных  файлов, которые составляют программу. Любая функция может вызвать функцию extern.

               Об"явления функций, в которых  опущен  спецификатор  класса памяти, считаются по умолчанию extern.

     Инициализация

               В об"явлении переменной может быть присвоено начальное зна­чение посредством инициализатора. Величина или величины инициали­затора присваиваются переменной.

               Синтаксически, записи инициализатора предшествует знак рав­но (=)

                 =<initializer>

               Могут быть инициализированы переменные любого типа. Функции не  инициализируются. Об"явления, которые используют спецификатор класса памяти extern не могут содержать инициализатора.

Переменные, об"явленные на внешнем уровне, могут быть  ини-

циализированы. Если они явно не инициализированы, то они устанав­ливаются  в  нуль во время компиляции или линкования. Любая пере­менная, об"явленная со спецификатором класса памяти static, может быть инициализирована константным выражением. Инициализация пере­менных класса static выполняется один раз  во  время  компиляции. Если отсутствует явная инициализация, то переменные класса памяти static автоматически устанавливаются в нуль.

               Инициализация переменных auto и register выполняется каждый раз при входе в блок, в котором они об"явлены. Если инициализатор опущен  в  об"явлении переменной класса памяти auto или register, то начальное значение  переменной  не  определено.  Инициализация

составных  типов  auto (массив, структура, совмещение) запрещена. Любое составное об"явление класса памяти static может быть иници­ализировано на внешнем уровне.

               Начальными значениями для внешних об"явлений  переменной  и для  всех  переменных  static как внешних так и внутренних должно быть константное выражение. Автоматические и регистровые перемен­ные могут быть инициализированы константными или переменными  ве­личинами.

Базовые типы и типы указателей

               Синтаксис:

               =<expression>

               Величина  выражения присваивается переменной. Для выражения допустимы правила преобразования.

               Примеры:

                 int x = 10;                    /* Example 1 */

register int *px = 0;          /* Example 2 */ int c = (3 * 1024);            /* Example 3 */ int *b = &x;                   /* Example 4 */

               В первом примере x инициализируется константным  выражением 10.  Во втором примере, указатель px инициализирован нулем, в ре­зультате чего получился "null" указатель. В третьем  примере  ис­пользуется константное выражение для инициализации c. В четвертом примере инициализируется указатель b адресом другой переменной x.

     Составные типы

               Синтаксис:

               ={<initializer-list>}

               Список  инициализаторов <initializer-list> - это последова­тельность инициализаторов, разделенных запятыми. Каждый инициали­затор в последовательности- это либо константное выражение,  либо список  инициализаторов.  Поэтому,  заключенный в фигурные скобки список, может появиться внутри другого списка инициализации.  Эта конструкция  используется  для  инициализации элементов составных конструкций.

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

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

               Эти правила применяются к каждому вложенному списку инициа­лизаторов, точно так же как и ко всей конструкции в целом.

               Пример:

               int p[4] [3] = {

                                       { 1, 1, 1 },

{ 2, 2, 2 }, { 3, 3, 3,}, { 4, 4, 4,},

                 };

               В  примере  об"является  массив p размерности 4 строки на 3 столбца. Элементы первой строки инициализируются 1, второй строки

2 и т. д. Заметим, что списки инициализаторов третьей и четвертой строк заканчиваются запятой. Последний список  инициализаторов  { 4, 4, 4,} также заканчивается запятой.

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

               int p[4] [3] = {

1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4

                 };

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

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

               typedef struct {

                           int n1, n2, n3;

                 } triplet;

                 triplet nlist[2] [3] = {

{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } },  /* Line 1 */ { { 10,11,12}, { 13,14,15}, { 15,16,17} }   /* Line 2 */

                 };

               В  примере nlist об"является как массив структур, состоящий из двух строк и трех столбцов. Каждая структура состоит  из  трех элементов.  Первая строка инициализации назначает величины первой строке массива nlist следующим образом:

               1. Первая левая фигурная скобка Line 1 информирует компиля­тор о том, что это начало  инициализации  первой  строки  массива nlist(nlist[0]).

               2. Вторая левая фигурная скобка означает то, что начинается инициализация  первого  элемента первой строки массива ( nlist[0] [0] ).

               3. Первая правая фигурная скобка сообщает об окончании ини­циализации первого элемента- структуры  nlist[0]  [0].  Следующая левая  фигурная  скобка  сообщает  о начале инициализации второго элемента первой строки nlist[0] [1].

               4. Процесс продолжается до конца Line 1 и заканчивается  по последней правой фигурной скобке.

               Аналогично, Line 2 назначает величины второй строке массива nlist.

               Заметим, что внешние фигурные скобки инициализаторов Line 1 и  Line 2 требуются. Следующая конструкция, в которой внешние фи­гурные скобки опущены будет неверной.

/* THIS CAUSES AN ERROR */

                 triplet nlist[2] [3] = {

                   { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 },  /* Line 1 */

                   { 10,11,12}, { 13,14,15}, {16,17,18 }   /* Line 2 */

               };

               В этом примере первая левая фигурная скобка в Line 1  стар­тует  инициализацию  nlist[0],  которая является массивом из трех структур. Величины 1, 2,  3  назначаются  трем  элементам  первой структуры. Когда встретится правая фигурная скобка (после величи­ны  3), инициализация nlist[0] закончится и две оставшиеся струк­туры автоматически инициализируются нулем. Аналогично, { 4, 5,  6 }  инициализирует  первую структуру во второй строке nlist, а ос­тавшиеся две структуры nlist[1] установятся в нуль. Когда  компи­лятор встретит следующий список инициализации { 7, 8, 9 }, то это приведет  к  попытке инициализировать nlist[2]. Так как nlist со­держит только две строки, то будет выдано сообщение об ошибке.

               Примеры:

/******************* Example 1 *********************/

                 struct list {

                                    int i, j, k;

                                     float n[2] [3];

                                    } x = {

                                                     1,

                                                     2,

                                                     3,

{4.0, 4.0, 4.0}

                                  };

/******************* Example 2 *********************/

                 union {

                                  char x[2] [3];

                                  int i, j, k;

                                  } y = {

                                                     {'1'},

                                                     {'4'}

                                  };

               В первом примере три элемента int структурной переменной  x инициализированы  1,  2,  и 3 соответственно. Три элемента первой строки массива m инициализированы как 4.0. Элементы второй строки инициализированы нулем по умолчанию.

               Во втором примере инициализируется переменная y типа совме­щения. Первым элементом совмещения является массив, для  которого требуется составной инициализатор. Список инициализации {'1'} за­дает величины для первой строки массива. Поскольку в списке всего одна  величина, то только первый элемент строки массива инициали­зируется символом 1 , а оставшиеся два элемента в строке  инициа­лизируются  нулем  (символом  \0)  по умолчанию. Аналогично, первый элемент второй строки массива x инициализируется  символом  4,  а оставшиеся два элемента в строке инициализируются нулем.

     Строковые инициализаторы

Массив может быть инициализирован строчным литералом.

               Например,

                 char code[ ] = "abc";

               инициализирует  code как массив символов из четырех элемен­тов. Четвертым элементом является символ \0, который завершает  все строковые литералы.

               Если  специфицируется  размер  массива, а строка больше чем

специфицированный размер, то лишние символы отбрасываются. Следу­ющее об"явление инициализирует переменную code, как  трехэлемент­ный массив символов:

               char code[3] = "abcd"

               В примере только три первые символа инициализатора назнача­ются для массива code. Символ d и сивол нуль отбрасываются.

               Если  строка  короче, чем специфицированный размер массива, то оставшиеся элементы массива инициализируются  нулем  (символом \0).

     Об"явления типов

               Об"явление  типа определяет имя и элементы структурного или совмещающего типов или имя и перечислимое множество перечислимого типа.

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

               Об"явление  typedef  определяет спецификатор типа для типа. Это об"явление используется для того, чтобы создавать  более  ко­роткие  или  более  осмысленные имена типов уже определенных в Си или об"явленных пользователем.

     Типы структур, совмещений и перечислений

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

               В об"явлении типа может появиться список об"явлений элемен­тов-       <member-declaration-list>    или   список   перечисления-

<enum-list>, определяющие тип.

               Сокращенная форма об"явления переменной, в котором tag ссы­лается на тип, определенный где-то еще, при  об"явлении  типа  не используется.

               Примеры:

/******************** Example 1 ********************/

                 enum status {

                                    loss = -1,

                                    bye,

                                    tie = 0,

                                    win,

                                    };

/********************* Example 2 *******************/

                 struct student {

                                    char name[20];

                                    int id, claas;

                                    };

               В  первом примере об"является тип перечисления, поименован­ный status. Имя типа может быть использовано в  об'явлениях  пер­менных типа перечисления. Идентификатор loss явно устанавливается в  -1.  Идентификаторы  bye и tie ассоциируются со значением 0, а win принимает значение 1. Во втором примере об"является структур­ный тип, поименованный student. Теперь можно  использовать  такое об"явление, как struct student employee, чтобы об"явить структур-

ную переменную employee типа student.

     Об"явления typedef

               Синтаксис:

typedef <type-spesifier><declarator>[,<declarator>...]; Об"явления typedef являются аналогом об"явления переменной,

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17