Ceg 221 lesson 2 homogeneous data types
This presentation is the property of its rightful owner.
Sponsored Links
1 / 16

CEG 221 Lesson 2: Homogeneous Data Types PowerPoint PPT Presentation


  • 40 Views
  • Uploaded on
  • Presentation posted in: General

CEG 221 Lesson 2: Homogeneous Data Types. Mr. David Lippa. Overview. Review of Homogeneous Data Types & Their Applications Arrays Data structures that we will briefly cover today, and in more detail later in the term: Lists – an ordinary unordered list Stacks – a “stack of plates”

Download Presentation

CEG 221 Lesson 2: Homogeneous Data Types

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


Ceg 221 lesson 2 homogeneous data types

CEG 221Lesson 2: Homogeneous Data Types

Mr. David Lippa


Overview

Overview

  • Review of Homogeneous Data Types & Their Applications

    • Arrays

    • Data structures that we will briefly cover today, and in more detail later in the term:

      • Lists – an ordinary unordered list

      • Stacks – a “stack of plates”

      • Queues – a line of people

  • Questions


What is a homogeneous data type

What is a Homogeneous Data Type?

  • A Homogeneous data type is a data type that is comprised solely of one type of data

    • Examples:

      • An array of integers (just a collection)

      • An (un)ordered list of integers

      • A stack of struct ProcessType* (an OS environment of running processes)

      • A queue of struct PersonType (ie. A line in the store or at Disneyland)


Arrays

Arrays

  • Arrays are a homogeneous data type that is the most basic collection of members of the same data types in chunks

    • Statically Allocated – hard-coded number of elements

      • Example: double pArray[15];

    • Dynamically Allocated – variable number of elements, with malloc/free (from stdlib.h)

      • Example: double *pArray = malloc( 15 * sizeof(double) );

  • Both examples are 15 doubles – but you have to allocate memory for everything you are storing at once time; cannot grow when full


Statically allocated arrays

Statically Allocated Arrays

  • The number of members allocated in a statically allocated array is constant, determined at compile time.

  • Advantages: easy to initialize arrays of basic types to “0”; memory freed when array goes out of scope; results in larger executables

    • double pArray[15] = {0};

  • Disadvantages: fixed number of elements (using a constant); always allocates memory whether it is used or not


Creating statically allocated arrays examples

Creating Statically Allocated Arrays: Examples

  • An initialized array of 15 ints:

    • int pArray[15] = {0}; // each int initialized to 0

  • A character string of 15 characters:

    • char pArray [16] = { ‘\0’ };

    • always null terminated with ‘\0’

  • An initialized array of 15 people:

    • struct PersonType pArray [15]; // allocate

    • for (i = 0; i < 15; i++) { /* initialize values*/ }


Dynamically allocated arrays

Dynamically Allocated Arrays

  • The number of members allocated in a dynamically allocated array can be determined by any value – a constant or a variable.

  • Advantages: requires a memset for any variables to initialize values to “0”; results in smaller executables

    • double *pArray = malloc( 15 * sizeof(double) ); // decl

    • memset( pArray, 0, 15 * sizeof(double) ); // init

  • Disadvantages: programmer must free memory when done or results in a memory leak; poor knowledge of pointers results in unstable code


Creating dynamically allocated arrays examples

Creating Dynamically Allocated Arrays: Examples

  • An initialized array of 15 ints:

    • int *pArray = malloc( 15 * sizeof(int) );

    • memset( pArray, 0, 15 * sizeof(int) );

  • A character string of 15 characters:

    • char *pArray = malloc(16);

    • memset( pArray, 0, 16 );

  • An initialized array of 15 people:

    • struct PersonType *pPerson =

      malloc( 15 * sizeof(struct PersonType) );

    • for (i = 0; i < 15; i++) { /* initialize values*/ }

  • Remember to free(pArray) when done and checking to see if pArray is NULL (allocation failed) before using it!


Accessing arrays

Accessing Arrays

  • To access an array, use the [] operator:

    • Indices go from 0 to n-1, where n is the size

    • The ith position starts from 0, not 1

      • The value at position 4 is the 5th element in the array

      • The 5th element of pArray is pArray[4]

  • Remember when using a dynamically allocated array, check to see if it is NULL


Reading writing statically allocated arrays

Reading/Writing Statically Allocated Arrays

  • To write a statically allocated character array to disk:

    char buf[360] = {‘0’};

    fwrite(&buf[0], sizeof(char), 360, pOutputFile);

  • Remember statically allocated arrays

    • are not accessible when out of scope

    • Are always passed by reference


Reading writing dynamically allocated arrays

Reading/Writing Dynamically Allocated Arrays

  • fwrite(buf, sizeof(char), 360, pOutputFile);

    • buf is a void*

    • sizeof(TYPE)

    • 360 – the number of items being written

    • pOutputFile – output stream

  • Remember

    • that all arrays are POINTERS

    • to check for ordinary pointers (ie. char*) if they are NULL prior to using them


  • Deleting dynamically allocated arrays

    Deleting Dynamically Allocated Arrays

    • Dynamically allocated arrays are not deleted for you, as other types are

    • You must instruct the program to delete it with the command free and then set it to NULL so that no other function can dereference a NULL pointer (results in crash)

    • Example:

      free(pPerson);

      pPerson = NULL;


    Putting it all together

    Putting it all together

    • Declare an array (& allocate memory if needed)

    • Initialize its values to 0 (or some empty value)

    • Set the elements of the array

    • Use the elements of the array

    • (When done, free memory if needed)


    Arrays putting it all together

    Arrays: Putting it all together

    {

    int numElements = 5;

    int *pIntList = malloc( numElements * sizeof(int) );

    double pDoubList[5] = {0};

    int i = 0;

    // populate both lists with needed values

    // use both arrays

    free(pIntList);

    }


    Next time

    Next Time

    • Advanced Input/Output

    • Advanced Data Types

    • Advanced Programming

    • String Processing using <string.h>


    Questions

    QUESTIONS?


  • Login