Memory allocation
1 / 11

Memory allocation - PowerPoint PPT Presentation

  • Uploaded on

Memory allocation. CSE 2451 Matt Boggus. sizeof. The sizeof unary operator will return the number of bytes reserved for a variable or data type. Determine: Returning the byte length of a data type Number of bytes reserved for a structure (user defined type)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' Memory allocation' - monet

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Memory allocation

Memory allocation

CSE 2451

Matt Boggus


  • Thesizeofunary operatorwill return the number of bytes reserved for a variable or data type.

  • Determine:

    • Returning the byte length of a data type

    • Number of bytes reserved for a structure (user defined type)

    • Byte length of an array

Returning the length of a data type
Returning the length of a data type

/* How big is an int?

Most machines size ints as 4 bytes */



printf("%d \n", sizeof(int));


Number of bytes reserved for a structure
Number of bytes reserved for a structure

/* On most machines a struct with two ints is the same size as two ints:8 */


struct {



} TwoInts;

printf("%d \n", sizeof(TwoInts));


Length of an array
Length of an array



char String[20];

printf("%d \n", sizeof String);

printf("%d \n", sizeof(String));


/* As a unary operator and not a function, parenthesis are not necessary (if the argument is a variable), but aid readability */

Dynamic memory functions
Dynamic memory functions

  • In the stdlib.h library:

  • malloc()

    • Allocate a memory block

  • free()

    • De-allocate memory

  • calloc()

    • Allocate space for an array

  • realloc()

    • Change the size of previously allocated memory

  • Each function is used to initialize a pointer with memory from free store (a section of memory available to all programs)


  • The function malloc() will allocate a block of memory that is size bytes large. If the requested memory can be allocated a pointer is returned to the beginning of the memory block.

  • Note: the content of the received block of memory is not initialized.

  • malloc() prototype:

    • void * malloc ( size_t size );

  • Parameters:

    • Size of the memory block in bytes.

  • Return value:

    • If the request is successful then a pointer to the memory block is returned.

    • If the function failed to allocate the requested block of memory, a null pointer is returned.

  • Example


Malloc usage
malloc usage

int*ptr = (int*) malloc( sizeof (int) );

int*ptr = (int*) malloc( sizeof (*ptr) );


  • calloc() prototype:

    • void * calloc ( size_tnum, size_t size );

  • Parameters:

    • Number of elements (array) to allocate and the size of elements.

  • Return value:

    • Will return a pointer to the memory block. If the request fails, a NULL pointer is returned.

  • Example:


Static vs dynamic memory
Static vs. Dynamic memory

  • Static arrays – size defined at compile time

    • Memory stored on the stack

    • Stack grows when entering new blocks (branches, loops, functions)

    • Stack shrinks when leaving blocks

    • Obeys scoping rules

  • Dynamic array – size defined at run time

    • Memory stored on the heap

    • Stays available until removed

      • In C – manually with function calls

      • In Java – automatically with garbage collection

  • Why have dynamic memory?

    • Input of unknown size

    • Data structures that require dynamic memory allocation

      • Linked lists, trees, etc.


  • The free function deallocates memory

  • free( ptr);

    • Frees the memory of whatever ptr is pointing at

  • After freeing a pointer, it is a good idea to set it to point to 0

    • This makes it a null pointer

    • Invalid dereferencing is easier to spot with NULL pointers

  • (Some compilers support explicitly setting a pointer to NULL)