Return to malloc CVS log

Up to [MW Coherent from dump] / coherent / a / usr / man / ALL

Annotation of coherent/a/usr/man/ALL/malloc, revision 1.1.1.1

1.1       root        1: 
                      2: 
                      3: malloc()                 General Function                malloc()
                      4: 
                      5: 
                      6: 
                      7: 
                      8: Allocate dynamic memory
                      9: 
                     10: cchhaarr *mmaalllloocc(_s_i_z_e) uunnssiiggnneedd _s_i_z_e;
                     11: 
                     12: malloc helps to manage  a program's free-space arenas.  It uses a
                     13: circular,  first-fit algorithm  to select an  unused block  of at
                     14: least  size  bytes, marks  the  portion it  uses,  and returns  a
                     15: pointer to it.  The function free returns allocated memory to the
                     16: free memory pool.
                     17: 
                     18: Each area  allocated by malloc is rounded up  to the nearest even
                     19: number and  preceded by  an unsigned  int that contains  the true
                     20: length.  Thus, if  you ask for three bytes you  get four, and the
                     21: unsigned that precedes the newly allocated area is set to four.
                     22: 
                     23: When an area is freed, its low order bit is turned on; consolida-
                     24: tion occurs  when malloc passes  over an area as  it searches for
                     25: space.  The end  of each arena contains a block  with a length of
                     26: zero, followed by a pointer to the next arena.  Arenas point in a
                     27: circle.
                     28: 
                     29: The  most  common  problem  with  malloc  occurs when  a  program
                     30: modifies  more space  than it  allocates  with malloc.   This can
                     31: cause later  mallocs to crash with a  message that indicates that
                     32: the arena has been corrupted.
                     33: 
                     34: ***** Example *****
                     35: 
                     36: This example  reads from the  standard input up  to NITEMS items,
                     37: each of  which is up to  MAXLEN long, sorts them,  and writes the
                     38: sorted  list  onto  the  standard  output.  It  demonstrates  the
                     39: functions qsort, malloc, free, exit, and strcmp.
                     40: 
                     41: 
                     42: #include <stdio.h>
                     43: #define NITEMS 512
                     44: #define MAXLEN 256
                     45: char *data[NITEMS];
                     46: char string[MAXLEN];
                     47: 
                     48: 
                     49: 
                     50: main()
                     51: {
                     52:         register char **cpp;
                     53:         register int count;
                     54:         extern int compare();
                     55:         extern char *malloc();
                     56:         extern char *gets();
                     57: 
                     58: 
                     59: 
                     60: 
                     61: 
                     62: 
                     63: 
                     64: COHERENT Lexicon                                           Page 1
                     65: 
                     66: 
                     67: 
                     68: 
                     69: malloc()                 General Function                malloc()
                     70: 
                     71: 
                     72: 
                     73:         for (cpp = &data[0]; cpp < &data[NITEMS]; cpp++) {
                     74:                 if (gets(string) == NULL)
                     75:                         break;
                     76:                 if ((*cpp = malloc(strlen(string) + 1)) == NULL)
                     77:                         exit(1);
                     78:                 strcpy(*cpp, string);
                     79:         }
                     80: 
                     81: 
                     82: 
                     83:         count = cpp - &data[0];
                     84:         qsort(data, count, sizeof(char *), compare);
                     85: 
                     86: 
                     87: 
                     88:         for (cpp = &data[0]; cpp < &data[count]; cpp++) {
                     89:                 printf("%s\n", *cpp);
                     90:                 free(*cpp);
                     91:         }
                     92:         exit(0);
                     93: }
                     94: 
                     95: 
                     96: 
                     97: compare(p1, p2)
                     98: register char **p1, **p2;
                     99: {
                    100:         extern int strcmp();
                    101:         return(strcmp(*p1, *p2));
                    102: }
                    103: 
                    104: 
                    105: ***** See Also *****
                    106: 
                    107: arena,  calloc(), free(),  general functions,  malloc.h, memok(),
                    108: realloc(), setbuf()
                    109: 
                    110: ***** Diagnostics *****
                    111: 
                    112: malloc returns NULL if insufficient memory is available.
                    113: 
                    114: ***** Notes *****
                    115: 
                    116: The commonest error  associated with mmaalllloocc is failing to declare
                    117: it  properly.  You  should always declare  mmaalllloocc as  returning a
                    118: pointer to char.
                    119: 
                    120: 
                    121: 
                    122: 
                    123: 
                    124: 
                    125: 
                    126: 
                    127: 
                    128: 
                    129: 
                    130: COHERENT Lexicon                                           Page 2
                    131: 
                    132: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.