Spring 2002 Test #2 Review Page

CSE1320 Sections 003 and 501                                                                   Dr. Tiernan’s sections

Topics to be covered on Test #2 with accompanying notes:

 

Main Topics                                                           Test #2 is IN CLASS Thursday, February 28th

Arrays

            be able to declare an array

            know the range of index values used for arrays

            understand how arrays are stored in memory

            declaring functions with arrays as parameters

            passing arrays as parameters

                        the whole array using pointer notation

                        a single element of an array

            accessing an array and its elements inside the function it has been passed to

            using arrays as pointers

            efficiency of array notation vs pointer arithmetic

Pointers

            know the rules for creating

            know what a pointer contains

            know the notation: *, &

            understand pointer arithmetic

            know the operations that can be performed on pointers

            be able to access the contents of the location the pointer points to

            vocabulary – dereference, indirection, addressing operator

            initializing pointers and NULL

            passing pointers as parameters

            allocating memory with pointers

                        malloc, calloc, free, casting pointer types

Strings

            declaring

            need for end-of-string markers

            difference from character arrays

Control Structures

      do-while

      switch

            syntax of cases

Recursion

      concept

      implementing recursion

            base case(s)

            recursive calls

      recursion vs. iteration

            cost / benefits

Structures

            creating data types

            declaring variables

            accessing members

            assignment of whole structures and of member value

            bit field members

                        defining

                        addressable boundaries

Enumerated types

            integer constants

            use in switch / benefits

Unions

            many members like a structure

            only one valid member at a time

            data in a member is only meaningful to a single member

            up to programmer to distinguish meaning

 

Secondary and Related Topics

Strings

            reading and writing strings

            common C library string functions

                        strlen(), strcpy(), strcat(), strcmp(),

Control Structures

      flow of control

            continue, break

            return, exit()

            goto

Functions

            know the rules for creating

                        function prototype declarations

                        function definitions

            understand the use of function parameters including void

                        know call-by-reference and call-by value

 

Test will have some or all of the following characteristics:

            multiple choice questions (not more than 10) – typically 1 to 2 points each

            short answer questions

            coding questions which require either

                        writing code or

                        interpreting code or

                        debugging code

                  ( “code” includes declarations, preprocessor directives, function definitions and

                  general coding of statements and control structures and I/O commands)

            matching questions

            fill-in-the-blank questions

      Questions generally have their point value listed in braces at the end/side of the question

      Every test will have at least 10 points worth of extra credit available

Test grades are assigned on a curve based on the range of actual scores on the test, i.e. the highest score on the test (for example, an 89) will be the top of the curve so all scores will be assigned based on where they fall (100 – 90 A, 89 – 80 B, etc.) AFTER the actual score has been divided by the curve.

 

The test will be hard. I write very challenging questions that require you to think all the way through them. A few of the questions will be memory type questions because some rules must be memorized to make a student an efficient programmer in a language. Most however will require lots of mental effort. Do not get too upset about it – remember EVERYONE is suffering through the same test you are and that everyone’s grade will be curved. Check out my website for a few example test questions from last semester’s tests. They will give you a sense of how my tests are written.