| <html lang="en"> | |
| <head> | |
| <title>Nested Functions - Using the GNU Compiler Collection (GCC)</title> | |
| <meta http-equiv="Content-Type" content="text/html"> | |
| <meta name="description" content="Using the GNU Compiler Collection (GCC)"> | |
| <meta name="generator" content="makeinfo 4.13"> | |
| <link title="Top" rel="start" href="index.html#Top"> | |
| <link rel="up" href="C-Extensions.html#C-Extensions" title="C Extensions"> | |
| <link rel="prev" href="Labels-as-Values.html#Labels-as-Values" title="Labels as Values"> | |
| <link rel="next" href="Constructing-Calls.html#Constructing-Calls" title="Constructing Calls"> | |
| <link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage"> | |
| <!-- | |
| Copyright (C) 1988-2013 Free Software Foundation, Inc. | |
| Permission is granted to copy, distribute and/or modify this document | |
| under the terms of the GNU Free Documentation License, Version 1.3 or | |
| any later version published by the Free Software Foundation; with the | |
| Invariant Sections being ``Funding Free Software'', the Front-Cover | |
| Texts being (a) (see below), and with the Back-Cover Texts being (b) | |
| (see below). A copy of the license is included in the section entitled | |
| ``GNU Free Documentation License''. | |
| (a) The FSF's Front-Cover Text is: | |
| A GNU Manual | |
| (b) The FSF's Back-Cover Text is: | |
| You have freedom to copy and modify this GNU Manual, like GNU | |
| software. Copies published by the Free Software Foundation raise | |
| funds for GNU development.--> | |
| <meta http-equiv="Content-Style-Type" content="text/css"> | |
| <style type="text/css"><!-- | |
| pre.display { font-family:inherit } | |
| pre.format { font-family:inherit } | |
| pre.smalldisplay { font-family:inherit; font-size:smaller } | |
| pre.smallformat { font-family:inherit; font-size:smaller } | |
| pre.smallexample { font-size:smaller } | |
| pre.smalllisp { font-size:smaller } | |
| span.sc { font-variant:small-caps } | |
| span.roman { font-family:serif; font-weight:normal; } | |
| span.sansserif { font-family:sans-serif; font-weight:normal; } | |
| --></style> | |
| </head> | |
| <body> | |
| <div class="node"> | |
| <a name="Nested-Functions"></a> | |
| <p> | |
| Next: <a rel="next" accesskey="n" href="Constructing-Calls.html#Constructing-Calls">Constructing Calls</a>, | |
| Previous: <a rel="previous" accesskey="p" href="Labels-as-Values.html#Labels-as-Values">Labels as Values</a>, | |
| Up: <a rel="up" accesskey="u" href="C-Extensions.html#C-Extensions">C Extensions</a> | |
| <hr> | |
| </div> | |
| <h3 class="section">6.4 Nested Functions</h3> | |
| <p><a name="index-nested-functions-2412"></a><a name="index-downward-funargs-2413"></a><a name="index-thunks-2414"></a> | |
| A <dfn>nested function</dfn> is a function defined inside another function. | |
| Nested functions are supported as an extension in GNU C, but are not | |
| supported by GNU C++. | |
| <p>The nested function's name is local to the block where it is defined. | |
| For example, here we define a nested function named <code>square</code>, and | |
| call it twice: | |
| <pre class="smallexample"> foo (double a, double b) | |
| { | |
| double square (double z) { return z * z; } | |
| return square (a) + square (b); | |
| } | |
| </pre> | |
| <p>The nested function can access all the variables of the containing | |
| function that are visible at the point of its definition. This is | |
| called <dfn>lexical scoping</dfn>. For example, here we show a nested | |
| function which uses an inherited variable named <code>offset</code>: | |
| <pre class="smallexample"> bar (int *array, int offset, int size) | |
| { | |
| int access (int *array, int index) | |
| { return array[index + offset]; } | |
| int i; | |
| /* <span class="roman">...</span> */ | |
| for (i = 0; i < size; i++) | |
| /* <span class="roman">...</span> */ access (array, i) /* <span class="roman">...</span> */ | |
| } | |
| </pre> | |
| <p>Nested function definitions are permitted within functions in the places | |
| where variable definitions are allowed; that is, in any block, mixed | |
| with the other declarations and statements in the block. | |
| <p>It is possible to call the nested function from outside the scope of its | |
| name by storing its address or passing the address to another function: | |
| <pre class="smallexample"> hack (int *array, int size) | |
| { | |
| void store (int index, int value) | |
| { array[index] = value; } | |
| intermediate (store, size); | |
| } | |
| </pre> | |
| <p>Here, the function <code>intermediate</code> receives the address of | |
| <code>store</code> as an argument. If <code>intermediate</code> calls <code>store</code>, | |
| the arguments given to <code>store</code> are used to store into <code>array</code>. | |
| But this technique works only so long as the containing function | |
| (<code>hack</code>, in this example) does not exit. | |
| <p>If you try to call the nested function through its address after the | |
| containing function exits, all hell breaks loose. If you try | |
| to call it after a containing scope level exits, and if it refers | |
| to some of the variables that are no longer in scope, you may be lucky, | |
| but it's not wise to take the risk. If, however, the nested function | |
| does not refer to anything that has gone out of scope, you should be | |
| safe. | |
| <p>GCC implements taking the address of a nested function using a technique | |
| called <dfn>trampolines</dfn>. This technique was described in | |
| <cite>Lexical Closures for C++</cite> (Thomas M. Breuel, USENIX | |
| C++ Conference Proceedings, October 17-21, 1988). | |
| <p>A nested function can jump to a label inherited from a containing | |
| function, provided the label is explicitly declared in the containing | |
| function (see <a href="Local-Labels.html#Local-Labels">Local Labels</a>). Such a jump returns instantly to the | |
| containing function, exiting the nested function that did the | |
| <code>goto</code> and any intermediate functions as well. Here is an example: | |
| <pre class="smallexample"> 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; | |
| /* <span class="roman">...</span> */ | |
| for (i = 0; i < size; i++) | |
| /* <span class="roman">...</span> */ access (array, i) /* <span class="roman">...</span> */ | |
| /* <span class="roman">...</span> */ | |
| return 0; | |
| /* <span class="roman">Control comes here from </span><code>access</code><span class="roman"> | |
| if it detects an error.</span> */ | |
| failure: | |
| return -1; | |
| } | |
| </pre> | |
| <p>A nested function always has no linkage. Declaring one with | |
| <code>extern</code> or <code>static</code> is erroneous. If you need to declare the nested function | |
| before its definition, use <code>auto</code> (which is otherwise meaningless | |
| for function declarations). | |
| <pre class="smallexample"> bar (int *array, int offset, int size) | |
| { | |
| __label__ failure; | |
| auto int access (int *, int); | |
| /* <span class="roman">...</span> */ | |
| int access (int *array, int index) | |
| { | |
| if (index > size) | |
| goto failure; | |
| return array[index + offset]; | |
| } | |
| /* <span class="roman">...</span> */ | |
| } | |
| </pre> | |
| </body></html> | |