Upload
others
View
3
Download
0
Embed Size (px)
Citation preview
Variable Names, Scope & Types
Terms when using variables What are some terms you think of when we discuss variables?1. Scope2. Naming3. Type.. (duh)4. But what else? What other terms are important when discussion variables?
Names Names refer to different kinds of entities in programs, such as variables,
functions, classes, templates, modules, . . . . Names can be reserved or user-defined Names can be bound statically or dynamically Name bindings have a scope: the program area where they are visible
Exercise with ExampleC++
can be any length, but often only the first 2048 characters are significant name cannot be a number
o int 100; // ERRORo name must start with a letter or a “_” (underscore)o name could contain numbers
int laneNumber2; variable names ARE VERY CASE SENSITIVE!!! NO SPACES OR SPECIAL CHARACTERS!!!
1
List the Differences from C++ about NAMING variablesR
PHPPerlJavaScript
Visual Basic
Scheme
Variable Declaration Essentially, variables are bindings of a name to a memory address They also have a type, value, scope, and lifetime Bindings can be
o dynamic (occur at run time), or o static (occur prior to run time)
a new name for an existing type is a type declarationo a new name for a new type is defined by specific its values using a data
declaration building new custom objects using a class construct go over more in Java
const int d = 400; void f() { double d = 100;{ double d = 200; std::cout << d;} std::cout << d; } double g() { return d+1;}
How Java and C++ set up their variables is also different!! (Next page)
2
Initialized Variables?C++#include <iostream>#include <string>using namespace std;
int main(){
cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
int x;string y;float z;
cout << "x is: " << x << endl;cout << "y is: " << x << endl;cout << "z is: " << x << endl;
return 0;}!!!Hello World!!!x is: 4201216y is: 4201216z is: 4201216
Java
Notice class variables are auto initialized, but not non-class.
3
Variable types primitives
o ints, float, Boolean, etc…o one language may not have a primitive that another does.
Wrapperso covered later
Customo objects built up of other datatypes
size of the same types between languages can vary!!
Fill in the table below of the sizes of each data type:C++ Java
ShortIntLonglong longFloatDoublelong doubleHow big can Java’s BigInteger get?How does Java handle unsigned?
4
Scope/Jurisdiction Scope is a property of a name binding The scope of a name binding are the parts of a program (collection of
statements, declarations, or expressions) that can access that binding Static/lexical scoping
o Binding’s scope is determined by the lexical structure of the program (and is thus known statically)
o The norm in most of today’s languageso Efficient lookup: memory location of each variable known at compile-
timeo Scopes can be nested
inner bindings hide the outer ones
Example of Jurisdiction MANY of you understand
In MARYLAND!!! (Apparently not in Texas!!)
5
Federal
State Police
County Police
Town Police
Campus PoPo
What are the scopes of names here, when are variables bound to types and values, and what are their scopes?
1. ID each variable2. Determine their original value3. Do the values change?4. What is the scope of each variable
Scope and Lifetime Exercise#include <iostream>const int d = 400;
void f(){ double d = 100; { double d = 200; std::cout << d << "\n";} // this is NOT an error std::cout << d << "\n";}
double g() { return d+1;}
int main(){ f(); std::cout << g() << "\n"; return 0;}
5. Try it out to prove if you are correct!a. Can use https://www.onlinegdb.com/online_c++_compiler
6
Static/Lexical Scoping & Binding also called static scoping
o static since values are deduced at compile time convention used with many programming languages that sets the scope
(range of functionality) of a variable so that it may only be called (referenced) from within the block of code in which it is defined
in shorto inner level can access its outer levels
Please don’t do this… but it’s an example
namespace std { ... }
namespace N { void f(int x) {};
class B { void f (bool b) { if (b) { bool b = false; // confusing but OK std::cout << b; } } };}
7
But if static, might not be consistent!!C++ JavaDoes this work in C++?? Code it!
Does this work in C++?? Code it!
This SHOULD work in C++
8
Copy, Paste, and run the Scheme code found here:http://faculty.cse.tamu.edu/slupoli/notes/Scheme/code/lexicalScoping/example1.txt
1. remember this is an example static scopinga. what does it mean to be static?
2. Make sure to understand WHY the results came out like they did!!
9
Dynamic Scoping Some early versions of LISP have dynamic scoping
o older languages Variable’s binding is taken from the most recent declaration encountered in
the execution path of the programo the outer scope depends on the chain of calls from functionso using this scoping rule, we first look for a local definition of a variableo if it isn't found, we look up the calling stack for a definition
Macro expansion of the C preprocessor gives another example of dynamic scoping
Makes reasoning difficult, since it is not consistent
Where Dynamic Scoping can be difficultExample 1// Since dynamic scoping is very uncommon in the familiar languages, we // consider the following pseudo code as our example.// It prints 20 in a language that uses dynamic scoping.int x = 10;
int f() { return x; }// Called by g()
int g() // g() has its own variable named as x and calls f(){ int x = 20; return f();}
main(){ printf(g()); // would print 20 if dynamic!// Why? Which variable was used last?}
Example 2#define ADD_A(x) x + a // who know what “a” could really be!
void add_one(int *x){ const int a = 1; x = ADD_A(x);}
10
void add_two(int *x) { const int a = 2; x = ADD_A(x); }
11
l- and r-valuesa = b;
“place” “thing”
// that’s why we read right to left // so our statement above would read “Put the “thing” into this “place””
[lvalue] = [rvalue]; // sure you’ve seen that error before
lvalue is our PLACE, must be defined and definite (that’s why “a+1 = b + 3;” will not work)
rvalue is our THING, can be anything to complete the statement or equation when we assign ANYTHING to a variable, we use a variable name to access
the memory that holds that data Depending on the context, a variable can denote the address (l-value), or the
value (r-value)
int x; x = x + 1;
Some languages distinguish between the syntax denoting the value and the address, e.g., in ML
x := !x + 1
From type checking perspective, l- or r-“valueness” is part of the type of an expression
12
Lifetime Time when a variable has memory allocated for it Scope and lifetime of a variable often go hand in hand A variable can be hidden, but still alive
Hidden Variable Examplevoid f (bool b){ if (b) { bool b = false; // hides the parameter b std::cout << b; }}
A variable can be in scope, but not alive (without value)o wasted memory!!
It’s (still) alive!!#include <iostream>using namespace std;
int main(){ cout << "Hello World" << endl;
int* a = new int(23); int& aref = *a; delete a; cout << "But the value is still there!! " << aref << endl; // aref should be set to null!!
return 0;}// aref is not alive, but in scope
Draw this out!! See why “aref” is dead.
13
Variable-Type Binding Types can be bound to variables statically or dynamically
Variable-Type BindingStatic
string x = “Hi”;x = 1.2; // error// Static binding may or may not require annotationsx = 23;x++;
Dynamicstring x = “Hi”;x = 1.2; // OK
Determine which languages allow static/dynamic.
Allow Static Allow Dynamic
14
Types and Type Systems Data typing is a mechanism by which a program tells the compiler or
interpreter how the data will be used Type defines and constrains how the data may be stored and what operations
may be performed on the data This allows a compiler to check for type errors, which helps to ensure that a
program is free of errors Types are collections of values (with operations that can apply to them) At the machine level, values are just sequences of bits Is this 0100 0000 0101 1000 0000 0000 0000 0000
o floating point number 3.375? o integer 1079508992? o two short integers 16472 and 0? o four ASCII characters @ X NUL NUL?
Programming at machine-level (assembly) requires that programmer keeps track of what are the types of each piece of data
Type errors (attempting an operation on a data type for which the operation is not defined) hard to avoid
Goal of type systems is to enable detection of type errors o reject meaningless programs
Pick one language, determine the types it has.
15
Languages w/ some type system, but unsound C, C++, Eiffel Reject most meaningless programs:
int i = 1; char* p = i;
but allow some
Unsound type systems
union { char* p; int i;} my_union;
void foo(){ my_union.i = 1; // ok here char* p = my_union.p; // iffy here . . .}
and deem the behavior undefined – just let the machine run and do whatever
16
Sound Type System Java and Haskell Reject some meaningless programs at compile-time:
int i = “Erroneous”;
Add checks at run-time so that no program behavior is undefined
Sound Type System example
interface Stack{ void push(Object elem); Object pop();}class MyStack { . . . }
Stack s = new MyStack();s.push(1);s.push(”whoAreYou…”);int i = (Int) s.pop(); // throws an exception // since it should have been a string!
Dynamic (but Sound) Type System Scheme, Javascript Reject no syntactically correct programs at compile time, types are enforced at
run-time:
; car – access 1st item in list; con – constructs a list
(car (cons 1 2)) ; ok, 1(car 5) ; error at run-time
Straightforward to define the set of safe programs and to detect unsafe ones
17
Type Systems Common errors
o examples of operations that are outlawed by type systems Add an integer to a function Assign to a constant Call a non-existing function Access a private field
Type systems can helpo in early error detectiono in code maintenanceo in enforcing abstractionso in documentationo in efficiency
18
Type Systems Terminology Static vs. dynamic typing
o Whether type checking is done at compile time or at run time Strong vs. weak typing
o Sometimes means no type errors at run time vs. possibly type errors at run time (type safety)
o Sometimes means no coercions vs. coercions (implicit type conversion)o Sometimes even means static vs. dynamic
Type inferenceo Whether programmers are required to manually state the types of
expressions used in their program or the types can be determined based on how the expr’s are used
o E.g., C requires that every variable be declared with a type; Haskell infers types based on a global analysis
Type Checking in Language Implementation Get into later with Grammar/Parsing/Syntactic Analysis
How type checking fits in
Answers19
Scope Exercise200100401
SourcesDr. Dylan Shell CSCE 314 Notes
Lexical/Static Scopehttps://stackoverflow.com/questions/1047454/what-is-lexical-scope https://whatis.techtarget.com/definition/lexical-scoping-static-scoping https://courses.cs.washington.edu/courses/cse341/14wi/general-concepts/scoping.html
20