Please enable JavaScript.

Coggle requires JavaScript to display documents.

(Binding variables to its attributes, allocated/deallocated at the…

- - - - Static
        
        known at the time of compilation
        
        Advantages
        
        Certain errors in programs can be detected earlier.
      - Dynamic
        
        can change during the course of the program execution.
        
        Advantages
        
        Programs can be more flexible and compact
        
        Generic Functions can be developed
        
        Disadvantages
        
        High run-time overhead (dynamic type checking) 1
        
        Compiler cannot detect type errors.
      - Type inference
        
        Rather than by assignment statement, types are determined from the context of the reference
        
        Types are determined from the context
        
        fun circumf(r) = 3.14 r r // r is real
        
        fun time10(x) = 10 * x // x is integer
        
        fun square(x) = x * x // ??? Illegal
        
        fun square(x):int = x* x // use explicit declarations
  - - - Typically storage required for a variable is taken from a pool
        of available memory – allocation
      - Releasing the memory cells allocated to a variable to the pool
        of available memory – deallocation
  - - - Lifetime begins when a variable is bound to a specific cell(s)
      - Lifetime ends when the variable is unbound from that cell(s)
- - - - Scope can be determined onlyy at run time
      - Requires keeping knowledge of names at runtime
      - Names refers to values in the most recently entered scope
      - The behavior of function can be changed without recompiling
      - Lead to programs which are difficult to read and maintain
    - - Some extra convenience
    - - Loss of readability
      - Unpredictable behavior
      - More run-time overhead
  - - - Visible everywhere
    - - Is an identifier in a block whose definition cannot be found in the same block
    - - Definition can be found in the same block
  - - - Local variable plus all visible variables in all active subprograms
    - - Local variables plus all of the variables in all the enclosing scopes
- - - - Types of names
        
        Variable names
        
        Formal parameter names
        
        Subprogram names
        
        Names for data types
        
        Names for defined constants
        
        Statement labels
        
        Exception names
        
        Names for literal constants
      - Name spaces
        
        cannot hae more than one meaning
        
        cannot share the same name in the same namespace
        
        Enable identifier names to be logically grouped
      - Naming conventions
        
        single lowercase letter
        
        single uppercase letter
        
        lowercase
        
        lower_case_with_underscores
        
        UPPERCASE
        
        UPPER_CASE_WITH_UNDERSCORES
        
        Pascal naming convention
        
        Camel naming convention
      - Name types
        
        Simple name a=a+1
        
        Composite name a[1]=a[1]+1
      - types of names typically used in programs
      - Design issues
        
        Maximum length of a name
        
        Case sensitiity
        
        Keywords or reserved words
        
        Name form
      - Constant and literal constant
        
        Constant
        
        a data object with a name that is bound to a value(s) permanently during its lifetime
        
        Literal constant
        
        a constant whose
        name is the written representation of its value
    - - The memory address with which a variable is associated
      - A variable(identified by its name) may have different addresses at different places in a program
      - A variable may have different addresses different times during execution
      - Aliasing
        
        Refer to the same storage location, x is called an alias of y
        
        To save storage by allowing the data at a particular location to be used differently at different times
        
        Different languages provide different ways to create aliases
        
        FORTRAN EQUIVALENCE
        
        Pascal, Ada Variant record structures
        
        Pointers
        
        Reference variables
        
        C and C++ Unions
        
        Problems
        
        Difficult to read and understand programs
        
        Program verification more difficult
    - - Contents of the location with which the variable is associated
        
        Ivalue
        
        Address of the variable
        
        rvalue
        
        Value of the variable
      - The value of the variable can be
        
        Actual value(Primitive Types)
        
        Reference Value(Aggregation Types)
    - - Restriction on the values it can hold and the operations that can be applied on it
    - - types based on lifetime
        
        Static
        
        Bounds to memory cells before program execution begins and remain bound to the same cells until the program terminates.
        
        Ex: Global variables C static variables FORTRAN 77 variables
        
        Advantages
        
        Efficiency
        
        Ability to create history sensitive variables
        
        No runtime overhead in allocation and deallocation
        
        Disadvantages
        
        Storage cannot be shared among variables
        
        No recursion possible
        
        Stack-dynamic(Automatic variables)
        
        Memory is allocated for variables when a function is called and deallocated when the function returns
        
        Variables stored in a region of memory called the stack
        
        Advantages
        
        Allow recursions
        
        Converse storage
        
        Disadvantages
        
        Memory allocation and deallocation overhead
        
        Not history sensitive
        
        Explicit heap-dynamic
        
        Nameless memory cells that are allocated and deallocated by explicit run-time instructions (‘malloc’ and ‘free’) specified by the programmer.
        
        Variables can only be referenced through pointer or reference variables
        
        Variables are allocated from and deallocated to the heap
        
        The memory remains
        allocated until explicitly
        deallocated using free in c
        
        Implicit heap dynamic
        
        refers to objects or variables that are
        allocated dynamically but without explicit memory management
        
        Memory allocation and deallocation are handled by the runtime
- - - - Specify types and other attributes
        
        Explicit declaration
        
        is a statement in a program that lists variable names and their type
        
        Implicit declaration
        
        variables are assigned types through default conventions
  - - - Int x = 0;
      - Int c[5] = {10,20,30,40,50}
      - int foo= c; / foois an alias of c */
- - - - Static scoping
        
        Evaluation
        
        Static scope often encourages many global variables
        
        Advantages
        
        Readability
        
        Locality of reasoning
        
        Less run time overhead
        
        Disadvantages
        
        Some loss flexibility
        
        Blocks
        
        Variables can be hidden from a unit by having a “closer” variable with the same name
        
        section of code in which local variables are