memory classes (original) (raw)
music
| 
| | OSdata.com |
| ---------------------------------------------------------------------------------------------- | | ---------- |
summary
This subchapter looks at memory classes.
stub section
This subchapter is a stub section. It will be filled in with instructional material later. For now it serves the purpose of a place holder for the order of instruction.
Professors are invited to give feedback on both the proposed contents and the propsed order of this text book. Send commentary to Milo, PO Box 1361, Tustin, California, 92781, USA.
memory classes
This subchapter looks at memory classes.
overview
Every variable in a program has a storage class (even if this hidden from the programmer, such as in BASIC). The storage class is the method for storing the variable in the computer’s memory.
A storage class determines where a variable or object is stored in memory and how long the memory allocation continues to exist (accessibility and longevity).
A few examples of storage classes are: a hardware register, a data stack, and a heap.
Most modern programming languages also have a scope. The scope is essentially when a variable is available for program use and what parts of a program can use the variable. When a variable is accessible by name it is considered to be in scope and “visible”.
The earliest version of scope was >b>global, meaning that the variable was available throughout the life of the program to any part of the program. The key problem with global scope is that any part of a program can change the value of a variable without informing any other part of the program. In effect, the world can change under your feet without warning and possibly without you even being aware that it has changed. That leads to unreliable programs and bugs that are extremely difficult to track down.
Accessibility of a variable indicates what portions of a program have access to a variable.
Longevity of a variable indicates the length of time a variable exists in a program.
The four storage classes in C are automatic, register, external, and static.
The three storage classes in C++ are automatic, external, and static.
Global variables are variables available for the entire life of a program to any part of a program. In C these are called external.
Local variables are variables that are created for a specific function or block of code. In C these are called automatic and are local to a specific function.
Register variables are variables stored in a hardware register rather than main memory. A compiler will typically move variables in and out of registers for faster processing, but those operations are hidden from the programmer’s view.
Static variables are local to a specific function or procedure, but are persistent. Normally all of the memory assigned to a procedure or function is freed up for other uses whent he procedure or function ends. Static variables are stored so that the function or variable will be able to save and use the variables from one call to the next.
Common block variables in FORTRAN are a block of memory for data storage.
Heap storage divides memory into blocks that are requested dynamically (at run time) by a program. This is typically used for such data structures as stacks, lists, trees, and graphs, but can also be used for large arrays or structures.
The following material is from the unclassified Computer Programming Manual for the JOVIAL (J73) Language, RADC-TR-81-143, Final Technical Report of June 1981.
The kinds of values provided by JOVIAL reflect the applications
of the language; they are oriented toward engineering and contrl
programming rather than, for example, commercial and business
programming. The JOVIAL values are:
9. Block values, which are collections of values gathered
into one region of memory. They are used to support
memory management. For example, certain data that must
be paged in and out of memory together can be placed in
a block.
Chapter 1 INTRODUCTION, page 3
1.1.2 Storage When a JOVIAL program is executed, each value it operates on is
stored as an item. The item has a name, which is declared and
then used in the program when the value of the item is fetched or
modified.
Chapter 1 INTRODUCTION, page 3
Items are just the scalar (single-value) data of JOVIAL. JOVIAL
also has tables and blocks, which provide for arrays and other
data structures. An example of a table declaration is: TABLE GRID (1:10, 1:10);
BEGIN
ITEM XOORD U;
ITEM YCOORD U;
END The table GRID has two dimensions. Each dimension contains ten
entries. Each entry consists of two items, XCOORD and YCOORD. An example of a block declaration is: BLOCK GROUP;
BEGIN
ITEM FLAG B;
TABLE DATA(100);
ITEM POINT U;
END The block GROUP contains the item FLAG and the table DATA.
Chapter 1 INTRODUCTION, page 5
free music player coding example
Coding example: I am making heavily documented and explained open source code for a method to play music for free — almost any song, no subscription fees, no download costs, no advertisements, all completely legal. This is done by building a front-end to YouTube (which checks the copyright permissions for you).
View music player in action: www.musicinpublic.com/.
Create your own copy from the original source code/ (presented for learning programming).
Because I no longer have the computer and software to make PDFs, the book is available as an HTML file, which you can convert into a PDF.
†UNIX used as a generic term unless specifically used as a trademark (such as in the phrase “UNIX certified”). UNIX is a registered trademark in the United States and other countries, licensed exclusively through X/Open Company Ltd.