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

   Нет. В программе на С++ вы можете вкладывать любые комбинации

   циклов.

СТРУКТУРА ПРОГРАММЫ

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

     Исходная программа

               Исходная программа- это  совокупность  следующих  об"ектов: директив,  указаний компилятору, об"явлений и определений. Дирек­тивы задают действия препроцессора по преобразованию текста прог­раммы перед компиляцией. Указания компилятору- это  команды,  вы­полняемые  компилятором  во время процесса компиляции. Об"явления задают имена и атрибуты переменных, функций и типов, используемых в программе. Определения- это об"явления, определяющие переменные и функции.

               Определение переменной в дополнении к ее имени и типу зада­ет начальное значение об"явленной переменной. Кроме того, опреде­ление предполагает распределение памяти для переменной.

Определение функции  специфицирует  ее  структуру,  которая

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

Исходная  программа  может  содержать любое число директив,

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

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

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

int x = 1;/* Variable definitions */

int y = 2;

extern int printf(char *,...);/* Function declaration */

main ()   /* Function definition for main function */

{

int z;    /* Variable declarations */

int w;

z = y + x;  /* Executable statements */

w = y - x;

printf("z = %d \nw = %d \n", z, x);

}

               Эта  исходная  программа определяет функцию с именем main и об"являет функцию printf. Переменные x и y задаются своими  опре­делениями. Переменные z и w только об"являются.

ОБЪЯВЛЕНИЯ

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

[<sc-specifier>][<type-specifier>]<declarator>[=<initializer>] [,<declarator>[=<initializer>...],

                 где:

<sc-specifier>- спецификатор класса памяти; <type-specifier>- имя определяемого типа;

                 <declarator>- идентификатор, который может быть модифициро­ван при об"явлении указателя, массива или функции;

               <initializer>-  задает значение или последовательность зна­чений, присваиваемых переменной при об"явлении.

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

               Язык Си определяет стандартное множество  типов  данных.  К этому       множеству можно добавлять новые типы данных посредством их

об"явлений на типах данных уже определенных.

               Об"явление Си требует одного или более деклараторов. Декла­ратор- это идентификатор, который может быть определен с квадрат­ными скобками ([]), эвездочкой (*) или круглыми скобками  ()  для об"явления  массива,  указателя  или  функции.  Когда об'является простая переменная  (такая  как  символ,  целое  или  плавающее), структура  или  совмещение простых переменных, то декларатор- это идентификатор.

               В Си определено четыре спецификатора класса памяти, а имен­но: auto, extern, register и static.

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

               Об"явления функций описаны в разделе 4.4.

                   Спецификаторы типов

               Язык  Си поддерживает определения для множества базовых ти­пов данных, называемых "основными" типами.  Названия  этих  типов перечислены в Табл. 4.1.

------------------------------------------------------------

            Типы целых                 Типы плавающих       Другие типы

------------------------------------------------------------

signed char                                float                void

signed int      double

signed short intsigned long int

unsigned char

unsigned int

unsignet short int unsigned long int

-----------------------------------------------------------

Табл. 4.1. Основные типы.

               Перечислимые  типы также рассматриваются как основные типы. Спецификаторы перечислимых типов рассмотрены в разделе 4.7.1. Ти­пы signed char, signed int, signed short int и  signed  long  int

вместе  с  соответствующими двойниками unsigned называются типами целых.

               Спецификаторы типов float и double относятся к типу "плава­ющих". В об"явлениях переменых и функций можно использовать любые спецификаторы "целый" и "плавающий".

               Тип void может быть использован только для об"явления функ­ций, которые не возвращают значения. Типы функций  рассмотрены  в разделе             4.4.

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

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

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

-----------------------------------------------------------

                 Спецификатор типа                                               Сокращение

-----------------------------------------------------------

                 signed char      char

                 signed int           signed, int

                 signed short int  short, signed short

                 signed long int   long, signed long

                 unsigned char  -

                 unsigned int    unsigned

                 unsigned short int                                                     unsignet short

                 unsignet long int                                                       unsignet long

                 float                                                                          -

                 long float           double

------------------------------------------------------------

                      Табл. 4.2. Спецификаторы и сокращения

               Замечание:  в этом руководстве в основном используются сок­ращенные формы, перечисленные в Табл. 4.2, при этом предполагает­ся, что char по умолчанию знаковый.

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

-----------------------------------------------------------

     Тип                             Представление      Область значений

в памяти           величины

-----------------------------------------------------------

     char                             1 байт             -128 до 127

     int                                  зависит от

                                           реализации

     short         2 байта            -32768 до 32767

long                             4 байта -2.147.483.648 до 2.147.483.647

     unsigned char                1 байт              0 до 255

     unsigned                        зависит от

                                           реализации

     unsigned short  2 байта 0 до 65535

     unsigned long                4 байта                                    0 до 4.294.967.295

     float  4 байта                IEEE   стандартное

                                                                                           соглашение

     double                            8 байт                                     IEEE   стандартное

                                                                                       соглашение ------------------------------------------------------------

       Табл 4.3 Размер памяти и область значений типов

               Тип char используется для запоминания буквы, цифры или сим­вола из множества представимых символов. Значением  об"екта  типа char является ASCII код, соответствующий данному символу. Так как тип  char  интерпретируется как однобайтовая целая величина с об­ластью значений от -128 до 127, то только величины от  0  до  127

имеют символьные эквиваленты. Аналогично, тип unsigned char может запоминать величины с областью значений от 0 до 255.

               Заметим,  что представление в памяти и область значений для типов int и unsigned int не определены в языке Си.  По  умолчанию размер int (со знаком и без знака) соответствует реальному разме­ру  целого  на данной машине. Например, на 16-ти разрядной машине тип int всегда 16 разрядов или 2 байта. На 32-ух разрядной машине тип int всегда 32 разряда или 4 байта. Таким образом, тип int эк­вивалентен типам short int или long int в зависимости от реализа­ции.

               Аналогично, тип unsigned int  эквивалентен  типам  unsigned short  или  unsigned long. Спецификаторы типов int и unsigned int широко используются в программах на Си, поскольку  они  позволяют наиболее  эффективно  манипулировать  целыми величинами на данной машине.

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

     Деклараторы

               Синтаксис:

               <identifier>

               <declarator>[]

               <declarator>[constant-expression>]

               *<declarator>

               <declarator>()

               <declarator>(<arg-type-list>)

               (<declarator>)

               Си позволяет об"являть: массивы величин, указатели на вели­чины, величины возвратов функций.  Чтобы  об"явить  эти  об"екты, нужно использовать декларатор, возможно модифицированный квадрат­ными  скобками  ([]),  круглыми скобками () и звездочкой (*), что соответствует типам массива, функции или  указателя.  Деклараторы появляются в об"явлениях указателей, массивов и функций.

Деклараторы массивов, функций и указателей

               Когда декларатор состоит из немодифицируемого идентификато­ра, то об'ект, который об"является, имеет немодифицированный тип. Звездочка, которая может появиться слева от идентификатора, моди­фицирует  его  в  тип  указателя. Если за идентификатором следуют квадратные скобки ([]), то тип модифицируется на тип массива. Ес­ли за идентификатором следуют круглые скобки, то тип  модифициру­ется  на  тип функции. Сам по себе декларатор не образует полного об"явления. Для этого в об"явление должен быть включен специфика­тор типа. Спецификатор типа задает тип элементов массива или  тип адресуемых об"ектов и возвратов функции.

               Следующие  примеры иллюстрируют простейшие формы декларато­ров:

               1. int list[20]

               2. char *cp

               3. double func(void),

               где:

               1. Массив list целых величин

               2. Указатель cp на величину типа char

               3.  Функция  func  без  аргументов,  возвращающая  величину double

     Составные деклараторы

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

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

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

               char *(*(*var) ()) [10];

               ^   ^ ^ ^ ^   ^   ^

               7   6 4 2 1   3   5

               1. Идентификатор var об'явлен как

               2. Указатель на

               3. Функцию, возвращающую

               4. Указатель на

5. Массив из 10 элементов, который состоит 6. Из указателей на

               7. Величины типа char.

               В следующих примерах  показывается  каким  образом  круглые скобки могут поменять смысл об"явлений.

               1. int *var[5]; - массив указателей на величины типа int.

               2. int (*var)[5]; - указатель на массив величин типа int.

               3.  long *var(long,long); - функция, возвращающая указатель на величину типа long.

               4. long (*var) (long,long); - указатель на функцию, возвра­щающую величину типа long.

               5. struct both {

                                           int a;

                                           char b;

                           } ( *var[5] ) ( struct both, struct both); массив указателей на функции, возвращающих структуры.

               6. double ( *var( double (*) [3] ) ) [3];

               функция, возвращающая указатель на массив из  трех  величин типа double.

               7. union sign {

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