Scope and lifetime of variable

SCOPE AND LIFETIME OF A VARIBALE

The scope of a vriable is the part of the program for which the declaration is in effect.

In Java, the scope of such a variable is from its declaration to the end of the method.

The lifetime of a variable is the time period in which the variable has valid memory.

In Java, the lifetime of a variable is the period of time beginning when the method is entered and ending when execution of the method terminates.

Types of Scope of a varibale:

• Local scope: "visible" within function or statement block from point of declaration until the end of the block.
• Global scope: visible everywhere unless "hidden".
• Class scope: "seen" by class members.
• Namespace scope: visible within namespace block.
• File scope: visible within current text file.

Type with lifetime of variable:

• Static: A static variable is stored in the data segment of the "object file" of a program. Its lifetime is the entire duration of the program's execution.
• Automatic: An automatic variable has a lifetime that begins when program execution enters the function or statement block or compound and ends when execution leaves the block. Automatic variables are stored in a "function call stack".
• Dynamic: The lifetime of a dynamic object begins when memory is allocated for the object (e.g., by a call to malloc() or using new) and ends when memory is deallocated (e.g., by a call to free() or using delete). Dynamic objects are stored in "the heap".

Principles of Programming Languages:

EasyExamNotes.com covered following topics in these notes.

• Language Evaluation Criteria
• Influences on Language Design 
• Language Categories
• Programming Paradigms
• Compilation
• Virtual Machines 
• Programming Environments
• Issues in Language Translation
• Parse Tree 
• Pointer and Reference type
• Concept of Binding
• Type Checking
• Strong typing 
• Sequence control with Expression
• Exception Handling 
• Subprograms
• Fundamentals of sub-programs
• Scope and lifetime of variable
• Static and dynamic scope
• Design issues of subprogram and operations
• Local referencing environments
• Parameter passing methods
• Overloaded sub-programs
• Generic sub-programs 
• Design issues for functions 
• Co routines 
• Abstract Data types
• Abstraction and encapsulation
• Static and Stack-Based Storage management
• Garbage Collection
• OOP in C++
• OOP in Java 
• OOP in C# 
• OOP in PHP
• Concurrency
• Semaphores 
• Monitors
• Message passing
• Java threads 
• C# threads 
• Exception handling 
• Exceptions
• Exception Propagation 
• Exception handler in C++ 
• Exception handler in Java
• Introduction and overview of Logic programming
• Basic elements of Prolog
• Application of Logic programming
• Functional programming languages
• Introduction to 4GL 

Practicals:

• Memory Implementation of 2D Array. 
• Memory Implementation of 3D Array. 
• Implementation of pointers in C++. 
• Write a program in Java to implement exception handling.
• Write a program in C++ to implement call by value parameter passing Method.
• Write a program in C++ to implement call by reference parameter passing Method. 
• Write a program in Java to implement concurrent execution of a job using threads.
• Implement Inheritance in C#.
• Implement Encapsulation in C#.
• Implement static/compiletime Polymorphism in C#.
• Implement dynamic/runtime Polymorphism in C#.

Previous years solved papers:

• PPL|RGPV|May 2018 
• PPL|RGPV|June 2017 

A list of Video lectures

• Click here

References:

1. Sebesta,”Concept of programming Language”, Pearson Edu 
2. Louden, “Programming Languages: Principles & Practices” , Cengage Learning 
3. Tucker, “Programming Languages: Principles and paradigms “, Tata McGraw –Hill. 
4. E Horowitz, "Programming Languages", 2nd Edition, Addison Wesley