В тех случаях, когда для одного имени определено неколько (различных) описаний функций, это имя называется прегруженным. При использовании этого имени правильная функция выбирается с помощью сравнения типов фактических параметров с типами формальных параметров в описаниях функций.
      Поиск того, какую функцию вызвать, осуществляется в три отдельных шага:
      Искать точно соответствующую и использовать, если найдна.
      Искать соответствующую с использованием стандартных пробразований (#6.6-8) и использовать любую найденную.
      Искать соответствующую с использованием определенных пользователем преобразований (#6.5.6). Если найдено единтвенное множество преобразований, использовать ее.
      Ноль, char или short считаются точно соответствующими формальному параметру типа int. Float считаются точно сооветствующими формальному параметру типа double.
      Над параметром перегруженной функции выполняются только следующе преобразования: int в long, int в double и преобрзования указателей и ссылок (#6.7-8).
      Для того, чтобы перегрузить имя функции не члена и не функции operator, любому описанию функции должно предшестввать описание overload, см. #8.1. Например:
      overload abs; double abs(double); int abs(int);
      abs(1); // вызывается abs(int); abs(1.0); // вызывается abs(double);
      Например:
      class X (* ... X (int); *); class Y (* ... Y (int); *);
      class Z (* ... Z (char*); *);
      overload int f (X), f (Y); overload int g (X), g (Z);
      f (1); // недопустимо: f(X(1)) или f(Y(1)) g (1); // g(X(1)) g («asdf»); // g(Z(«asdf»))
      Операция взятия адреса amp; может применяться к перегруженому имени только в присваивании или инициализации, когда ожидаемый тип определяет, адрес какой функции брать. Напрмер:
      int operator=(matrix amp;, matrix amp;); int operator=(vector amp;, vector amp;); int (*pfm)(matrix amp;, matrix amp;) = amp;operator=; int (*pfv)(vector amp;, vector amp;) = amp;operator=; int (*pfx)(...) = amp;operator=;

      Перечисления являются типами int с именованными констатами.
      enum_спецификатор: enum идентификатор opt (* enum_список *)
      enum_список: перечислитель enum_список , перечислитель
      перечислитель: идентификатор идентификатор = константное_выражение
      Идентификаторы в enum-списке описаны как константы и мгут появляться во всех местах, где требуются константы. Если не появляется ни одного перечислителя с =, то значения сооветствующих констант начинаются с 0 и возрастают на 1 по мере чтения описания слева нарпаво. Перечислитель с = дает ассоцированному с ним идентификатору указанное значение; последущие идентификаторы продолжают прогрессию от присвоенного знчения.
      Имена перечислителей должны быть отличными от имен обычных переменных. Имена перечислителей с разными константми тоже должны быть различны. Значения перечислителей не обзательно должны быть различными.
      Роль идентификатора в спецификаторе перечисления enum_спецификатор полностью аналогична роли имени класса; он именует определенный нутератор. Например:
      enum color (* red, yellow, green=20, blue *); color col = red;
      color *cp = amp;col; if (*cp == blue) // ...
      делает color именем типа, описывающего различные цвета, и затем описывает col как объект этого типа, а cp как указтель на объект этого типа. Возможные значения лежат во мнжестве (* 0, 1, 20, 21 *).

      Описание Asm имеет вид
      asm ( строка );
      Смысл описания asm неопределен. Обычно оно используется для передачи информации ассемблеру через компилятор.
      9. Операторы
      Операторы выполняются последовательно во всех случаях кроме особо оговоренных.

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

      Составной оператор (называемый также «блок», что эквивлентно) дает возможность использовать несколько операторов в том месте, где предполагается использование одного:
      составной_оператор: (* список_операторов opt *)
      список_операторов: оператор оператор список_операторов
      Обратите внимание, что описание – это вариант оператора (#9.14).

      Есть два вида условных операторов
      if ( выражение ) оператор if ( выражение ) оператор else оператор
 
      Выражение должно быть арифметического или указательного типа или классового типа, для которого определено преобразвание в арифметический или указательный тип (см. #8.5.6). Вчисляется выражение, и если оно не ноль, то выполняется певый подоператор. Если используется «else», то второй подоператор выполняется, если выражение есть 0. Как обычно, неоднозначность «else» разрешается посредством того, что else связывается с последним встречнным if, не имеющим else.

      Оператор while имеет вид
      while ( выражение ) оператор
      Выполнение подоператора повторяется, пока значение выржения остается ненулевым. Проверка выполняется перед каждым выполнением оператора. Выражение обрабатывается как в услоном операторе (#9.3).

      Оператор do имеет вид
      do оператор while ( выражение ) ;
      Выполнение подоператора повторяется до тех пор, пока значение остается не нулем. Проверка выполняется после каждго выполнения оператора. Выражение обрабатывается как в уловном операторе (#9.3).

      Оператор for имеет вид
      for (оператор_1 выражение_1 opt; выражение_2 opt) оператор_2
      Этот оператор эквивалентен следующему:
      оператор_1 while ( выражение_1 ) (* оператор_2 выражение_2 ; *)
      за исключением того, что continue в операторе_2 будет выполнять выражение_2 перед выполнением выражения_1. Первый оператор, таким образом, задает инициализацию цикла; первое выражение задает выполняемую перед каждой итерацией проверку, по которой производится выход из цикла, если выражение станвится нулем; второе выражение часто задает приращение, выпоняемое после каждой итерации.
 
      Каждое или оба выражения могут быть опущены. Отсутствие выражения_1 делает подразумеваемое while-предложение эквивлентым while(1). Заметьте, что если оператор_2 является опсанием, то область видимости описанного имени распространяеся до конца блока, охватывающего оператор for.

      Оператор switch вызывает передачу управления на один из нескольких операторов в зависимости от значения выражения. Он имеет вид
      switch ( выражение ) оператор
      Выражение должно быть арифметичского или указательного типа. Любой оператор внутри оператора может быть помечен оной или более меток case следующим образом:
      case константное_выражение :
      где константное выражение должно иметь тот же тип что и выражение-переключатель; производятся обычные арифметические преобразования. В одном операторе switch никакие две констаты, помеченные case, не могут иметь одинаковое значение. Константные выражения определяются в #12.
      Также может быть не более чем одна метка вида
      default :
      Когда выполнен оператор switch, проведено вычисление его выражения и сравнение его с каждой case константой. Если одна из констант равна значению выражения, то управление передаеся на выражение, следующее за подошедшей меткой case. Если никакая case константа не соответствует выражению, и есть метка default, то управление передается на выражение, которму она предшествует. Если нет соответсвующих вариантов case и default отсутствует, то никакой из операторов в операторе switch не выполняется.
      Метки case и default сами по себе не изменяют поток уравления, который после задерки идет дальше, перескакивая чрез эти метки. Для выхода из switch см. break, #9.8.
      Обычно зависящий от switch оператор является составным. В голове этого оператора могут стоять описания, но инициалзации автоматических и регистровых переменных являются безрзультатными.

      Оператор
      break ;
      вызывает завершение выполнения наименьшего охватывающего оператора while, do, for или switch; управление передается на
      оператор, следующий за завершенным.

      Оператор
      continue ;
      вызывает передачу управления на управляющую продолжением цикла часть наименьшего охватывающего оператора while, do или for; то есть на конец петли цикла. Точнее, в каждом из оперторов
      while (...) (* do (* for (...) (* ... ... ... contin: ; contin: ; contin: ; *) *) while (...); *)
      continue эквивалентно goto contin. (За contin: идет путой оператор, #9.13.)

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

      Можно осуществлять безусловную передачу упраления с пмощью оператора
      goto идентификатор ;
      Идентификатор должен быть меткой (#9.12), расположенной в текущей функции. Невозможно передать управление в обход описания с инициализатором (явным или неявным) никак, кроме передачи управления в обход внутреннего блока без захода в него.

      Перед любым оператором может стоять метка, имеющий вид
 
      идентификатор :
      которая служит для описания идентификатора как метки. Метка используется только как объект перехода для goto. Оластью видимости метки является текущая функция, исключая лбой подблок, в котором был переописан этот же идентификатор. См. #4.1.

      Пустой оператор имеет вид
      ;
      Пустой оператор используется для помещения метки непоредственно перед *) составного оператора или того, чтобы снабдить такие операторы, как while, пустым телом.

      Оператор описание используется для введения нового идетификатора в блоке; он имеет вид
      Оператор_описание: описание
      Если введенный описанием идентификатор был описан ранее во внешнем блоке, внешнее описание становится скрытым на пртяжении блока, после чего оно вновь всупает в силу.
      Каждая инициализация auto и register переменных произвдится каждый раз, когда выполняется их оператор_описание. Можно передавать управление в блок, но не таким путем, котрый приводит к невыполнению инициализаций, см. #9.11. Иницилизации переменных класса памяти static (#4.4) производятся только один раз, когда программа начинает выполняться. 10. Определения Функций
      Программа состоит из последовательности описаний. Код (текст программы) функции может быть задан только вне всех блоков и внутри описаний классов. Определения функций имеют вид
      определение_функции: спецификаторы_описания opt описатель_функции инициализатор_базового opt тело_функции
      Спецификаторы_описания register, auto, typedef не могут использоваться внутри описания класса (#8.5), а friend и virtual могут использоваться только там. Описатель функции – это описатель «функции, возвращающей ...» (#8.4).Формальные параметры находятся в области видимости самого внешнего блока тела_функции. Описатели функции имеют вид
      описатель_функции:
      описатель ( список_описаний_параметров )
      Если параметр специфицирован как register, то соответтвующий фактический параметр будет по возможности копироватся в регистр на входе в функцию. Если для параметра специфцировано константное выражение в качестве инициализатора, то это значение используется как значение параметра по умолчнию.
      Тело функции имеет вид
      тело_функции: составной_оператор
      Вот простой пример полного определения функции:
      int max(int a, int b, int c) (* int m = (a « b) ? a : b; return (m » c) ? m : c; *)
      Здесь int – это спецификатор_типа; max(int a, int b, int c) – это описатель_функции; (* ... *) – это тело_функции.
      Поскольку в контексте выражения имя моссива (в особености, как фактического параметра) принимается как означающее указатель на первый элемент массива, описания формальных праметров, которые описаны как «массив из ...», корректируются так, чтобы читались как «указатель на ...».
      В определении конструктора могут быть заданы инициализторы для базового класса и для членов. Это главным образом полезно для объектов класса, констант и ссылок, где семантика инициализации и присваивания различаются. Инициализатор_базвого имеет вид
      инициализатор_базового: : список_инициализаторов_членов
      список_инициализаторов_членов: инициализатор_члена инициализатор_члена , список_инициализаторов_членов
      инициализатор_члена: идентификатор opt ( список_параметров opt )
      Если в инициализаторе_члена дан идентификатор, то список параметров используется для инициализации названного члена; если нет, то список параметров используется для базового класса. Например:
      struct base (* base(int); ... *);
      struct derived : base (* derived(int); base b; const c;
      *);
      derived::derived(int a) : (a+1), b(a+2), c(a+3) (* /* ... */ *)
      derived d(10);
      Сначала конструктор базового класса вызывается для обекта d с параметром 11, затем вызывается конструктор для члна b с параметром 12 и конструктор для члена c с параметром 13. Затем выполняется тело derived::derived() (см. #8.5.5). Порядок, в котором вызываются конструкторы для членов, не утановлен. Если базовый класс имеет конструктор, который можно вызывать без параметров, не надо давать никакой список парметров. Если класс члена имеет конструктор, который можно взывать без параметров, для этого члена не надо давать никакой список параметров.

      Компилятор содержит препроцессор, способный выполнять макроподстановки, условную компиляцию и включение именованных файлов. Строки, начинающиеся с #, относятся к препроцессору. Эти строки имеют независимый от остального языка синтаксис; они могут появляться в любом месте и оказывать влияние, котрое распространяется (независимо от области видимости) до конца файла исходной программы.
      Учтите, что определения const и inline дают альтернативы для большинства использований #define.

      Командная строка компилятора вида
      #define идентификатор строка_лексем вызывает замену препроцессором последующих вхождений идентификатора, заданного строкой символов. Точка с запятой внутри (или в конце) строки символов является частью этой строки.
      Строка вида
      #define идентификатор( идентификатор , ... , идентификатор) строка_лексем
      где нет пробела между первым идентификатором и (, явлется макроопределением с параметрами. Последующие вхождения первого идентификатора с идущими за ним (, последователностью символов, разграниченной запятыми, и ), заменяются строкой символов, заданной в определении. Каждое местоположние идентификатора, замеченного в списке параметров определния, заменяется соответствующей строкой из вызова. Фактичекими параметрами вызова являются строки символов, разделенные запятыми; однако запятые в строке, заключенной в кавычки, или в круглых скобках не являются разделителями параметров. Число формальных и фактических параметров должно совпадать. Строки и символьные константы в символьной строке сканируются в писках формальных параметров, но строки и символьные константы в остальной программе не сканируются в поисках определенных
      (с помощью define) идентификаторов.
      В обоих случаях строка замещения еще раз сканируется в поисках других определнных идентификаторов. В обоих случаях длинное определение может быть продолжено на другой строке с помощью записи \ в конце продолжаемой строки.
      Командная строка вида
      #undef идентификатор
      влечет отмену препроцессорного определения идентификатра.

      Командная строка компилятора вида
      #include «имя_файла»
      вызывает замену этой строки полным содержимым файла имя_ файла. Сначала именованный файл ищется в директории первончального исходного файла, а затем в стандартных или заданных местах. Альтернативный вариант, командная строка вида
      #include «имя_файла»
      производит поиск только в стандартном или заданном мете, и не ищет в директории исходного файла. (То, как эти мета задаются, не является частью языка.) Включения с помощью #include могут быть вложенными.

      Командная строка компилятора вида
      #if выражение
      проверяет, является ли результатом вычисления выражения не-ноль. Выражение должно быть константным выражением, котрые обсуждаются в #12. Кроме обычных операций С++ может ипользоваться унарная операция defined. При применении к идетификатору она дает значение не-ноль, если этот идентификатор был ранее определен с помощью #define и после этого не было отмены определения с помощью #undef; иначе ее значение 0. Командная строка вида
      #ifdef идентификатор
      проверяет, определен ли идентификатор в препроцессоре в данный момент; то есть, был ли он объектом командной строки # define. Командная строка вида
 
      #ifndef идентификатор
      проверяет, является ли идентификатор неопределенным в препроцессоре в данный момент.
      После каждого из трех видов может стоять произвольное количество строк, возможно, содержащих командную строку
      #else
      и далее до командной строки
      #endif
      Если проверенное условие истинно, то все строки между #else и #endif игнорируются. Если проверенное условие ложно, то все строки между проверкой и #else или, в случае отсуттвия #else, #endif, игнорируются.
      Эти конструкции могут быть вложенными.

      Для помощи другим препроцессорам, генерирующим программы на С++, строка вида
      #line константа «имя_файла»
      заставляет компилятор считать, например, в целях дианостики ошибок, что константа задает номер следущей строки исходного файла, и текущий входной файл именуется идентификтором. Если идентификатор отсутствует, то запомненное имя файла не изменяется.

      В нескольких местах С++ требует выражения, вычисление которых дает константу: в качестве границ массива (#8.4), в case выражениях (#9.7), в качестве значений параметров фунции по умолчанию (#8.3), и в инициализаторах (#8.6). В первом случае выражение может включать только целые константы, сивольные константы, константы перечислений, значения несостаных const, инициализированных константными выражениями, и sizeof выражения, возможно, связанные бинарными операциями
      + – * / % amp; ! ^ «„ “» == != « » «= »= amp; amp; !!
      или унарными операциями
      + – ~ !
      или тернарной операцией
      ?:
 
      Скобки могут использоваться для группирования, но не для вызова функций.
      Во всех остальных случаях константное выражение может также содержать унарную операцию amp;, примененную к внешним или статическим объектам, или к внешним или статическим массивам, индексированным константным выражением. Унарная операция amp; может также быть применена неявно с помощью употребления ниндексированных массивов и функций. Основное правило состоит в том, что инициализаторы должны при вычислении давать контанту или адрес ранее описанного внешнего или статического обйекта плюс или минус константа.
      Меньшая широта допустима для константных выражений после #if: недопустимы имена, описанные const, sizeof выражения и перечислимые константы.
      13. Соображения Мобильности
      Определенные части С++ являются машинно зависимыми по своей сути. Следующий ниже список мест возможных затруднений не претендует на полноту, но может указать на основные из них.
      Как показала практика, характеристики аппаратуры в читом виде, такие, как размер слова, свойства плавающей арифмтики и целого деления, не создают особых проблем. Другие апаратные аспекты отражаются на различных программных разработках. Некоторые из них, особенно знаковое расширение (преобразование отрицательного символа в отрицательное целое) и порядок расположения байтов в слове, являются досадными пмехами, за которыми надо тщательно следить. Большинство отальных являются всего лишь мелкими сложностями.
      Число регистровых переменных, которые фактически могут быть помещены в регистры, различается от машины к машине, как и множество дейсвующих типов. Тем не менее, все компиляторы на «своей» машине все делают правильно; избыточные или ндействующие описания register игнорируются.
      В языке неопределен порядок вычисления параметров фунции. На некоторых машинах он слева направо, а на остальных справа налево. Порядок появления побочных эффектов также ндетерминирован.
      Поскольку символьные константы в действительности явлются объектами типа int, то могут быть допустимы многосивольные константы. Однако конкретная реализация очень сильно зависит от машины, поскольку порядок, в котором символы приваиваются слову, различается от машины к машине.
      14. Краткое Изложение Синтаксиса
      Эта краткая сводка синтаксиса С++ предназначается, чтобы способствовать пониманию. Она не является точной формулирокой языка.

      выражение: терм выражение бинарная_операция выражение выражение ? выражение : выражение список_выражений
      список_выражений: выражение список_выражений , выражение
      терм: первичное_выражение унарная_операция терм терм ++ терм – sizeof выражение sizeof ( имя_типа ) ( имя_типа) выражение простое_имя_типа ( список_выражений ) new имя_типа инициализатор opt new ( имя_типа ) delete выражение delete [ выражение ] выражение
      первичное_выражение: id :: идентификатор константа строка this ( выражение ) первичное_выражение[ выражение ] первичное_выражение ( список_выражений opt ) первичное_выражение.id первичное_выражение-»id
      id: идентификатор typedef-имя :: идентификатор typedef-имя :: имя_функции_операции
      операция: унарная_операция бинарная_операция специальная_операция операция_свободной_памяти
      Бинарные операции имеют приоритет, убывающий в указанном порядке:
      бинарная_операция: одна из * / % + – «„ “» « »
      == != amp; ^ ! amp; amp; !! операция_присваивания
      операция_присваивания: одна из = += -= *= /= %= ^= amp;= != »»= ««=
      унарная_операция: одна из * amp; + – ~ ! ++ –
      специальная_операция: одна из () []
      операция_свободной_памяти: одна из new delete
      имя_типа: спецификаторы_описания абстрактный_описатель
      абстрактный_описатель: пустой * абстрактный_описатель абстрактный_описатель ( список_описаний_параметров ) абстрактный_описатель [ константное_выражение opt ]
      простое_имя_типа: typedef-имя char short int long unsigned float double void
 
      typedef-имя: идентификатор

      описание: спецификаторы_описания opt список_описателей opt ; описание_имени asm-описание
      описание_имени: сост идентификатор ; enum идентификатор ;
      сост:
      class struct union
      asm-описание: asm ( строка ) ;
      спецификаторы_описания: спецификатор_описания спецификаторы_описания opt
      спецификатор_описания: спецификатор_класса_памяти спецификатор_типа спецификатор_функции typedef friend
      спецификатор_типа: простое_имя_типа спецификатор_класса спецификатор_enum усложненный_спецификатор_типа const
      спецификатор_класса_памяти: auto extern register static
      спецификатор_функции: inline overload virtual
      усложненный_спецификатор_типа: ключ typedef-имя ключ идентификатор
      ключ: class struct union enum
      список_описателей: иниц-описатель иниц-описатель , список_описателей
      иниц-описатель: описатель инициализатор opt
      описатель: оп_имя ( описатель ) * const opt описатель amp; const opt описатель
      описатель ( список_описаний_параметров ) описатель [ константное_выражение opt ]
      оп_имя: простое_оп_имя typedef-имя :: простое_оп_имя
      простое_оп_имя: идентификатор typedef-имя ~ typedef-имя имя_функции_операции имя_функции_преобразования
      имя_функции_операции: operator операция
      имя_функции_преобразования operator тип
      список_описаний_параметров: список_описаний_прм opt ... opt
      список_описаний_прм: список_описаний_прм , описание_параметра описание_параметра
      описание_параметра: спецификаторы_описания описатель = выражение спецификаторы_описания описатель = константное_выражение спецификаторы_описания абстракт_описатель = выражение спецификаторы_описания абстракт_описатель = выражение
      спецификатор_класса: заголовок_класса (* список_членов opt *) заголовок_класса (* список_членов opt public : список_членов opt *)
      заголовок_класса: сост идентификатор opt сост идентификатор opt : public opt typedef-имя
      список_членов: описание_члена список_членов opt
      описание_члена: спецификаторы_описания opt описатель_члена инициализатор opt ; определение_функции opt
      описатель_члена: описатель идентификатор opt : константное_выражение
      инициализатор: = выражение = (* список_инициализаторов *) = (* список_инициализаторов , *) ( список_выражений )
 
      список_инициализаторов: выражение список_инициализаторов , список_инициализаторов (* список_инициализаторов *)
      спецификатор_enum: enum идентификатор opt (* enum-список *)
      enum-список: перечислитель enum-список , перечислитель
      перечислитель: идентификатор идентификатор = константное_выражение

      составной_оператор: (* список_операторов opt *)
      список_операторов: оператор оператор список_операторов
      оператор: описание составной_оператор выражение opt ; if ( выражение ) оператор if ( выражение ) оператор else оператор while ( выражение ) оператор do оператор while ( выражение ) ; for ( оператор выражение opt ; выражение opt ) оператор switch ( выражение ) оператор case константное_выражение : оператор default : оператор break ; continue ; return выражение opt ; goto идентификатор ; идентификатор : оператор

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

      #define идентификатор строка_лексем
      #define идентификатор( идентификатор,...,идентификатор ) строка лексем #else #endif #if выражение #ifdef идентификатор #ifndef идентификатор #include «имя_файла» #include «имя_файла» #line константа «имя_файла» #undef идентификатор

      Типы параметров функции могут быть заданы (#8.4) и будут проверяться (#7.1). Могут выполняться преобразования типов (# 7.1).
      Для выражений с числами с плавающей точкой может исползоваться плавающая арифметика одинарной точности; #6.2.
      Имена функций могут быть перегружены; #8.9.
      Операции могут быть перегружены; 7.16, #8.5.11.
      Функции могут быть inline-подставляемыми; #8.1.
      Объекты данных могут быть константными (const); #8.3.
      Могут быть описаны объекты ссылочного типа; #8.4, #8.6.3
      Операции new и delete обеспечивают свободное хранение в памяти, #7.2.
      Классы могут обеспечивать сокрытие данных (#8.5.9), грантированную инициализацию (#8.6.2), определяемые пользовтелем преобразвания (#8.5.6), и динамическое типизирование через использование виртуальных функций (#8.5.4).
      Имя класса или перечисления является именем типа; #8.5.
 
      Любой указатель может присваиваться void* без применеия приведения к типу; #7.14.
      Описание внутри блока является оператором; #9.14.
      Можно описывать безымянные объединения; #8.5.13.

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