CSE 465 Midterm 2

variable

Is an abstraction of a memory cell

Scope

range of statements over which a variable is visible

Reserved words

a special word of a programming language that cannot be used as a name

static

A binding is ______ if it first occurs before run time begins and remains unchanged throughout the program execution

Dynamic

If the binding first occurs during runtime or can change in the course of the program execution

explicit declaration

is a statement in the program that lists variable names and specifies that they are a particular type

implicit declaration

is a means of associating variables with types through default conventions

implicit declaration

First appearance of a variable name in a program is ______

reference environment of a statement

the set of all names that are visible in the statement

static scope

local variables plus all the visible variables in all the enclosing scopes

dynamic scope

local variables plus all visible variables in all active subprograms

dynamically typed

what type of language is python?

Object oriented

What type of language is C#?

\*

de-reference operator

&

reference operator

pointer type variable

has a range of values that consists of memory addresses and a special value,nil.

the address of

&var reads as

type \*

declares a pointer to an object of the data type type

new type

allocates new object on the heap and returns a pointer to that object

\*var

dereference operator

\*var reads as

the value/data stored at the pointer address

memory leak

memory that is no longer needed is not released

dangling pointer

a pointer that contains the address of a heap-dynamic variable that has been deallocated

5

Let L = \[7,6,5,4,3\]. What does the following return? \n len(L)

4

Let L = \[7,6,5,4,3\]. What does the following return? \n L\[-2\]

\[6, 5, 4\]

Let L = \[7,6,5,4,3\]. What does the following return? \n L\[1:4\]

\[\]

Let L = \[7,6,5,4,3\]. What does the following return? \n L\[1:4:-1\]

\[3, 5\]

Let L = \[7,6,5,4,3\]. What does the following return? \n L\[4:1:-2\]

\[6, 5, 4, 3\]

Let L = \[7,6,5,4,3\]. What does the following return? \n L\[1:7\]

F

T/F: All elements of a list must have the same type.

F

T/F: All variables must be declared prior to use.

T

T/F: -1 is a potentially valid index for a list (i.e., if L is a long-enough list, L\[-1\] would return an element).

T

T/F: Python has an if-elif-else conditional statement.

Case sensitivity \n Special words (reserved or keywords) \n Length \n Special characters

Design issues for names

Variable

An abstraction of a (collection of) memory cell(s)

int \*x = new int; \n (new int represents the nameless variable)

Representation of a nameless variable

T

T/F: A variable's memory address may be different at different times during execution or at different places in a program

Variable Type

Determines the range of values of variables and the set of operations that are defined for values of that type

Variable Value

The contents of the location with which the variable is associated

Its address

What is the l-value of a variable?

Its value

What is the r-value of a variable?

Binding

An association between an entity and an attribute, such as between a variable and its type or value, or between an operation and a symbol

Binding time

The time at which binding takes place

Language design time \n Language implementation time \n Compile time \n Load time \n Runtime

Possible Binding Times

1D \n 2A \n 3B \n 4C \n 5E

MATCH: \n \n 1. Language design time \n 2. Language implementation time \n 3. Compile time \n 4. Load time \n 5. Runtime \n \n A. Binding floating point type to a representation; int to a range of values \n B. Binding a variable to a type in C or Java \n C. Binding a C or C++ static variable to a memory cell \n D. Binding operator symbols to operations (e.g., \* to multiplication) \n E. Binding a nonstatic local variable to a memory cell

Explicit declaration

a program statement used for declaring the types of variables

Dynamic binding

First occurs during execution or can change during execution of the program

Static binding

Occurs before run time and remains unchanged throughout program execution

Implicit declaration

\
a default mechanism for specifying types of variables through default conventions/naming requirements or inferencing, rather than declaration statements

Type inferencing

Use context to determine the type of a variable \n C#: var

Dynamic type binding

Specified through an assignment statement e.g., JavaScript \n l = \[2, 4.33, 6, 8\]; \n l = 17.3; \n A variable's type can change multiple times during program execution

Allocation

Getting a cell from some pool of available cells

Deallocation

Putting a cell back into the pool

Lifetime

The time during which a variable is bound to a particular memory cell

Static Variable

bound to memory cells before execution begins and remains bound to the same memory cell throughout execution, e.g., C and C++ static variables in functions

Static variable advantage

efficiency (direct addressing)

Static variable disadvantage

lack of flexibility (no recursion)

Stack-dynamic variables

storage bindings are created for variables when their declaration statements are elaborated \n a declaration is elaborated when the executable code associated with it is executed

allows recursion; conserves storage

Static-dynamic variable advantage

overhead of allocation and deallocation \n subprograms cannot be history sensitive \n inefficient references (indirect addressing)

Static-dynamic variable disadvantages

Explicit heap-dynamic variables

\
Allocated and deallocated by explicit directives, specified by the programmer, which take effect during execution \n Referenced only through pointers or references, e.g., dynamic objects in C++ (via new and delete), all objects in Java \n \n ex: new int

provides for dynamic storage management

Explicit heap-dynamic variable advantage

inefficient and unreliable

Explicit heap-dynamic variable disadvantage

Implicit heap-dynamic variables

allocation and deallocation caused by assignment statements \n e.g., all strings and arrays in Perl, JS, and PHP

flexibility (generic code)

Implicit heap-dynamic variable advantage

inefficient b/c all attributes are dynamic \n loss of error detection

Implicit heap-dynamic variable disadvantages

Variable scope

The range of statements over which a variable is visible

Local variables

Declared in that unit

Nonlocal variables

Visible in the unit but not declared there

Global variables

Special category of nonlocal variables

Based on program text \n To connect a name reference to a variable, you or the compiler must find the declaration

Static Scope (Lexical Scope)

Dynamic Scope

Based on calling sequences of program units, not their textual layout (temporal versus spatial) \n \n References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point

Referencing Environments

The set of all names that are visible in a given statement

Python Global Scope

A global variable can be referenced in functions but can be assigned in a function only if it has been declared to be global in the function \n (Similarly for nonlocal variables)

Python with statement

Ensures that file(s) is/are properly closed after the nested block of code, no matter how the nested block exits (e.g., even if exceptions occur)

Python indentation

How blocks of code are defined (i.e., by having the same indentation)

Dynamically (binding of variables to data type happens at runtime)

Python is a _ typed language

Immutable, references

Tuples are _, but they contain object _.

for i in range(n): \n print(i) \n \n for x in myList: \n print(x)

Python for loop template

Object-oriented, C++, Java

C# is an _ language derived from _ and _.

Garbage collection, automatic memory management

C# supports _ and

T, but the support is limited-can only hold the memory address of value types and arrays, not reference types

T/F: C# supports pointers

\*

C# de-reference operator

&

C# reference operator

F, it can contain multiple classes

T/F: A portable executable C# file can only contain one class

namespaces

C# classes are grouped in _, which are NOT related to directories

Capital

C# library methods start with a capital or lowercase letter?

foreach (var x in myArray) \n Console.WriteLine(x)

C# for loop template

Fields

Member variables or methods in a class

Properties

An extension of fields that are accessed using the same syntax using accessors

Indexers

Allow objects of a class to be indexed like an array

var lines = File.ReadAllLines(args\[0\]); \n foreach (var line in lines) { \n Console.WriteLine(line); \n }

C# reading from a file code template

Non-generic collections that can be enumerated (i.e., you can foreach to iterate through its elements)

C# IEnumerable Interface

foreach

Implementing the IEnumerable interface allows use with _ syntax

Ienumerator

For IEnumerable, you must also implement the interface _.

MoveNext()

Enumerator objects are positioned before the first element in the collection and they get advanced to the first element by the first call to _.

Pointers (in C, C++)

Have a range of values that consist of memory addresses and a special value, nil

new (type)

allocates new object on the heap and returns a pointer to that object \n \n ex: \n int\* p; \n p = new int; \n ... \n delete p;

pointers \n \n ex: \n int a\[5\]; is almost equivalent to int\* a; \n int a\[5\]; is equivalent to const int\* a;

Arrays in C++ are implemented as _

Traditional array notation: a\[3\] \n Pointer arithmetic: \*(a + 3)

How can elements of an array be dereferenced?