(libc.info.gz) Memory Allocation and C

Info Catalog

(libc.info.gz) Memory Allocation

(libc.info.gz) Unconstrained Allocation

 
 3.2.1 Memory Allocation in C Programs
 -------------------------------------
 
 The C language supports two kinds of memory allocation through the
 variables in C programs:
 
    * "Static allocation" is what happens when you declare a static or
      global variable.  Each static or global variable defines one block
      of space, of a fixed size.  The space is allocated once, when your
      program is started (part of the exec operation), and is never
      freed.  
 
    * "Automatic allocation" happens when you declare an automatic
      variable, such as a function argument or a local variable.  The
      space for an automatic variable is allocated when the compound
      statement containing the declaration is entered, and is freed when
      that compound statement is exited.  
 
      In GNU C, the size of the automatic storage can be an expression
      that varies.  In other C implementations, it must be a constant.
 
    A third important kind of memory allocation, "dynamic allocation",
 is not supported by C variables but is available via GNU C library
 functions.  
 
 3.2.1.1 Dynamic Memory Allocation
 .................................
 
 "Dynamic memory allocation" is a technique in which programs determine
 as they are running where to store some information.  You need dynamic
 allocation when the amount of memory you need, or how long you continue
 to need it, depends on factors that are not known before the program
 runs.
 
    For example, you may need a block to store a line read from an input
 file; since there is no limit to how long a line can be, you must
 allocate the memory dynamically and make it dynamically larger as you
 read more of the line.
 
    Or, you may need a block for each record or each definition in the
 input data; since you can't know in advance how many there will be, you
 must allocate a new block for each record or definition as you read it.
 
    When you use dynamic allocation, the allocation of a block of memory
 is an action that the program requests explicitly.  You call a function
 or macro when you want to allocate space, and specify the size with an
 argument.  If you want to free the space, you do so by calling another
 function or macro.  You can do these things whenever you want, as often
 as you want.
 
    Dynamic allocation is not supported by C variables; there is no
 storage class "dynamic", and there can never be a C variable whose
 value is stored in dynamically allocated space.  The only way to get
 dynamically allocated memory is via a system call (which is generally
 via a GNU C library function call), and the only way to refer to
 dynamically allocated space is through a pointer.  Because it is less
 convenient, and because the actual process of dynamic allocation
 requires more computation time, programmers generally use dynamic
 allocation only when neither static nor automatic allocation will serve.
 
    For example, if you want to allocate dynamically some space to hold a
 `struct foobar', you cannot declare a variable of type `struct foobar'
 whose contents are the dynamically allocated space.  But you can
 declare a variable of pointer type `struct foobar *' and assign it the
 address of the space.  Then you can use the operators `*' and `->' on
 this pointer variable to refer to the contents of the space:
 
      {
        struct foobar *ptr
           = (struct foobar *) malloc (sizeof (struct foobar));
        ptr->name = x;
        ptr->next = current_foobar;
        current_foobar = ptr;
      }
 

Info Catalog

(libc.info.gz) Memory Allocation

(libc.info.gz) Unconstrained Allocation