6.4 Вложенные функции

Вложенная функция — это функция, определённая внутри другой функции. Вложенные функции поддерживаются как расширение в GNU C, но не поддерживаются в GNU C++.

Имя вложенной функции является локальным для блока, в котором она определена. Например, здесь мы определяем вложенную функцию с именем square, и вызываем её дважды:

foo (double a, double b)
{
  double square (double z) { return z * z; }

  return square (a) + square (b);
}

Вложенная функция может получить доступ ко всем переменным содержащей функции, которые видны в момент её определения. Это называется лексическим охватом. Например, здесь мы показываем вложенную функцию, использующую унаследованную переменную с именем offset:

bar (int *array, int offset, int size)
{
  int access (int *array, int index)
    { return array[index + offset]; }
  int i;
  /* ... */
  for (i = 0; i < size; i++)
    /* ... */ access (array, i) /* ... */
}

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

Возможен вызов вложенной функции извне области видимости её имени путём хранения её адреса или передачи адреса другой функции:

hack (int *array, int size)
{
  void store (int index, int value)
    { array[index] = value; }

  intermediate (store, size);
}

Здесь функция intermediate получает адрес store в качестве аргумента. Если intermediate вызывает store, аргументы, переданные store, используются для хранения в array. Однако эта техника работает только до тех пор, пока содержащая функция (hack, в данном примере) не завершит свою работу.

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

GCC реализует получение адреса вложенной функции с помощью техники, называемой трамплинами. Эта техника была описана в статье «Лексические замыкания для C++» (Thomas M. Breuel, Труды конференции USENIX C++ Conference, 17–21 октября 1988 года).

Вложенная функция может перейти по метке, унаследованной от содержащей функции, при условии, что метка явно объявлена в содержащей функции (см. Локальные метки). Такой переход мгновенно возвращает управление содержащей функции, завершая работу вложенной функции, которая выполнила goto и все промежуточные функции. Вот пример:

bar (int *array, int offset, int size)
{
  __label__ failure;
  int access (int *array, int index)
    {
      if (index > size)
        goto failure;
      return array[index + offset];
    }
  int i;
  /* ... */
  for (i = 0; i < size; i++)
    /* ... */ access (array, i) /* ... */
  /* ... */
  return 0;

 /* Control comes here from access
    if it detects an error.  */
 failure:
  return -1;
}

Вложенная функция всегда не имеет связи. Объявление её с extern или static является ошибочным. Если вам нужно объявить вложенную функцию до её определения, используйте auto (что в противном случае не имеет смысла для объявлений функций).

bar (int *array, int offset, int size)
{
  __label__ failure;
  auto int access (int *, int);
  /* ... */
  int access (int *array, int index)
    {
      if (index > size)
        goto failure;
      return array[index + offset];
    }
  /* ... */
}