using variables chapter 10-11. outline 2 variable initialization scope persistence using each...
Post on 05-Jan-2016
224 Views
Preview:
TRANSCRIPT
Using Variables
Chapter 10-11
Outline
2
Variable Initialization Scope Persistence Using Each Variable for Single Purpose Variable Names
Data Literacy Test
3
abstract data type array bitmap boolean variable b-tree character variable container class double precision elongated stream enumerated type floating point heap index integer linked list named constant
literal local variables lookup table member data pointer private retroactive synapse referential integrity stack string structured variable tree typedef union value chain variant Total Score
1: familiar 0.5: know what a term means but aren’t sure
Loose Interpretation
4
0-14: beginning programmer 15-19: intermediate programmer, or
An experienced programmer who has forgotten a lot
20-24: expert programmer 25-29: know more about data types than
Steve Consider writing your own book
30-32: your are a pompous fraud Elongated stream, retroactive synapse, value
chain don’t refer to data types
Variable Initialization Problem
5
A variable may contain an initial value that you do not expect it to contain Never been assigned a value Outdated: assigned a value at some point, but no
longer valid Part of the variable assigned a value, part has not
Guidelines for Variable Initialization
6
Initialize each variable as it is declared Inexpensive form of defensive programming
Initialize each var close to where it’s first used Some languages (e.g., VB) do not support initializing
variables as they are declared Principle of proximity: keep related action together
Ideally, declare and define each variable close to where it’s first used
int accountIndex = 0;// code using accountIndex …double total = 0.0;// code using total …boolean done = false; // code using done while ( ! done ) { ... }
Guidelines for Variable Initialization
7
Use final or const when possible Pay attention to counters and accumulators
Forget to reset before the next time it is used Initialize a class’s member data in constructor Check the need to re-initialization
Used by a loop used many times Needs to be reset between calls
Use the compiler setting that automatically initialize variables
Guidelines for Variable Initialization
8
Take advantage of compiler’s warning messages
Check input parameters for validity Use a memory access checker to check for
bad pointers Initialize working memory to a known value at
the beginning of your program
Scope
9
Scope or visibility The extent to which the variable is known and can
be referenced throughout the program Minimizing vs maximizing scope
Maximizing scope Convenience, e.g., global variables Easier to write; Harder to understand/debug/modify
Minimizing scope Keep variables as local as possible Intellectual manageability, Easier to read
Code programs to read or write?
Localize References to Variables
10
The code between references to a variable is a ‘window of vulnerability’ New code might be added, inadvertently altering
the variable Someone reading the code might forget the value
the variable is supposed to contain Measure how close together the references
are span
Variable Span
11
a =0;b=0;c=0;b=a+1b=b/c; 1 line between 1st/2nd references to b: span of 1 0 line between 2nd/3rd references to b: span of 0
Average span For b, (1+0)/2=0.5
Live Time
12
Total # of statements over which a variable is live
Life begins/ends at the first/last reference
isn't affected by how many times the variable is used between the first and last times it's referenced.
Measuring Live Time
13
1 // initialize all variables2 recordIndex = 0 ;3 total = 0;4 done = false;…26 while (recordIndex<recordCount){27 …28 recordIndex = recordIndex+1; …64 while (!done) { …69 if (total>projectedTotal) {70 done = true;
recordIndex: 28-2+1total: 69-3+1done: 70-4+1Average: 54
Measuring Live Time - cont
14
…25 recordIndex = 0 ;26 while (recordIndex<recordCount){27 …28 recordIndex = recordIndex+1; …62 total = 0 ;63 done = false;64 while (!done) { …69 if (total>projectedTotal) {70 done = true;
recordIndex: 28-25+1total: 69-62+1done: 70-63+1Average: 7
Keep Variables ‘Live’ for a Short Time
15
Keep live time as short as possible: advantages Reduce the window of vulnerability Concentrate on a smaller section of code Reduce the chance of initialization errors Make the code more readable Easier for refactoring or splitting a large routine
into smaller routines
What Do You Think?
16
void SummarizeData(…){…GetOldData( oldData, &numOldData);GetnewData(newData, &numNewData);totalOldData = sum(oldData, numOldData);totalNewData = sum(newData, numNewData);PrintOldDataSummary(oldData, totalOldData, numOldData);PrintNewDataSummary(newData, totalNewData,
numNewData);SaveOldDataSummary(totalOldData, numOldData);SaveNewDataSummary(totalNewData, numNewData);…
}
17
Guidelines for Minimizing Scope
Guidelines for Minimizing Scope
18
Group related statements, and, if necessary, break related statements into separate routines
Don't assign a value to a variable until just before the value is used
Guidelines for Minimizing Scope
19
Initialize variables used in a loop immediately before the loop rather than back at the beginning of the routine containing the loop When modify the loop, remember to make
corresponding modifications to the initialization Favor the smallest possible scope
Local to a specific loop, local to a routine, private to a class, then protected, then package,
Global only as last resort
Persistence
20
Some variables persist For the life of a block of code or routine
Variables inside a for loop As long as you allow them to
Objects created with new persist until garbage collected
For the life of a program Global variables
Forever Variables include values in database
Problem If you assume that a variable has a longer
persistence than it really does
Avoiding Persistence Problem
21
Use debug code or assertions to check critical variables for reasonable values
Set variables to unreasonable values when you are through with them Set a pointer to null after you delete it
Write code that assumes data isn’t persistent Develop the habit of declaring and
initializing all data right before it’s used Be suspicious if data is used without a nearby
initialization.
What Do You Think?
22
// compute roots of a quadratic equation// this code assumes that (b*b-4*a*c) is positivetemp = sqrt (b*b-4*a*c);root[0] = (-b + temp) / (2*a);root[1] = (-b - temp) / (2*a);…//swap the rootstemp = root[0];root[0] = root[1];root[1] = temp;
Using Each Variable for Single Purpose
23
Using the same variable for different purposes makes it seem as though they are related when they’re not! Use discriminant for the first temp Use oldRoot for the second temp
Using Each Variable for Single Purpose
24
Avoid variables with hidden meanings - different values mean different things customerID: a customer number unless its
value>=500,000, in which case subtracting 500,000 results in the number of a delinquent account
Make sure all declared variables are used
What Do You Think?
25
x = x –xx;xxx = fido + SalesTax(fido);x = x +LateFee(x1, x) + xxx;x = x + Interest(x1, x);
Kinds of Names to Avoid
26
Avoiding misleading names or abbreviations Avoid names with similar meanings
recordNum/numRecords Avoid names that sound similar
wrap/rap Avoid numerals in names Avoid misspelled words in names Don’t differentiate names solely by
capitalization Avoid multiple natural languages
check/cheque
Kinds of Names to Avoid - cont
27
Avoid the names of standard types, variables, and routines
If if=then then then = else;else else = if; // PL/1
Avoid names containing hard-to-read chars (1, l, I), (0, O), (2, Z), (S, 5), ...
Don’t use names that are totally unrelated to what the variables represent
Reading
28
The Power of Variable Names ‘Code Complete’ Chapter 11.
top related