Joseph R. Shinnerl

bit

Binary Digit. That is, a variable quantity capable of holding exactly one of two possible values. By convention, these values are labeled 0 (zero) and 1 (one). A byte is 8 bits.
A kilobyte (KB) is 2¹⁰ bytes = 1024 bytes.
A megabyte (MB) is 2²⁰ bytes = 1024 KB.
A gigabyte (GB) is 2³⁰ bytes = 1024 MB.
A terabyte (TB) is 2⁴⁰ bytes = 1024 GB.
A petabyte (PB) is 2⁵⁰ bytes = 1024 TB.
An exabyte (EB) is 2⁶⁰ bytes = 1024 PB.

type

A rule or set of rules for

1. the translation of certain symbols or symbol sequences into a specified number of bits
2. the syntax involving identifiers declared to have that type.

Notes:

• A type is either exact or inexact. In C++, the basic built-in types are bool, char, int, and float. Of these, float is inexact; the others are exact. Exact types are also called integral, because they represent discrete quantities. Inexact types are usually represented in floating-point and can be thought of as truncated and rounded approximations to real numbers.
• From the basic built-in types, the following types are derived: enumerations, void, pointer types, array types, reference types, and programmer-defined types (structs and classes).
• Type void is essentially the absence of any translation rule or storage size. One may therefore argue that void is not a proper type at all. For this reason, void is sometimes called a syntactic type to distinguish it from the other types, which specify both syntax and storage conventions.
• There are some important variations on the int and float types. The most important of these, by far, is the floating-point type double. A double is similar to a float, but it uses about twice as many digits in its representation. For nearly all practical purposes, approximate values should be stored as doubles rather than as floats.
• Definitions of built-in types may vary from one platform to another. An int on your personal computer may not have exactly the same meaning as an int on larger, smaller, older, or newer computers with the same or different operating systems.
• Because individual bits in most machines are not actually addressable, a variable of type bool uses the same number of bits as a variable of type char.

object

A contiguous region of memory with a type. First-class objects are endowed with all the "usual" operations, e.g., assignment, and can generally be handled just as the basic built-in types (int, double, char, bool) are handled. Second-class objects (e.g., arrays) have special syntactical restrictions on their usage (e.g., assignment is not defined for arrays).

grammar

The formal definition of the language. The grammar specifies what combinations of symbols are legal and how these combinations are evaluated.

expression

A sequence of symbols that can be reduced to a single value of a specific type.
Notes:

• The reduction is performed according to the grammar of the language.
• Expressions are typically nested. Most expressions are actually combinations of smaller, simpler expressions. Numbers and identifiers are examples of primitive expressions (they cannot be reduced further).

identifier

A programmer-specified name; a sequence of characters associated with and used to access a particular object, class or struct, or function. Every identifier has a scope.

scope

The source code extending from a declaration up until the end of the block which contains the declaration.

lifetime

The interval of run-time during which a particular object is reserved for use by the program.

The lifetime of an object whose memory is reserved at compile time (a statically allocated object) is simply the time required to execute the instructions for all statements in its scope. A statically allocated object "dies" when its identifier goes out of scope. The lifetime of an object whose memory is reserved at run-time (a dynamically allocated object) extends from the time at which the memory is allocated to the time at which is deallocated. For dynamically allocated objects, there is no connection between scope and lifetime.

declaration

The introduction of a name (identifier) into a scope.

definition

The association of an identifier with a specific object (in memory).

Every definition is also a declaration, and most declarations are also definitions. But not every declaration is a definition. For example, extern int i; introduces the identifier i into the current scope, but the extern specifier says that the associated object was already created elsewhere (e.g., another file) in the source code.

statement

Any of the following:

• A declaration.
• An expression followed by a semi-colon.
• A sequence of statements enclosed within curly braces: a block.
• A selection-control structure (an if or switch block); a case or default block within a such a structure.
• An iteration-control structure (a for, while, or do while loop).
• Any unconditional transfer of control of the form break;, continue;, return;, or goto expression ;.
• A statement preceded by an identifying label and a colon.
• An exception-handler block (a try-catch block).

Note: Many authors reserve the word block for sequences of statements that contain declarations.

parse

To break a program, statement, or expression into its component parts.

compiler

A program that translates high-level source code, e.g., C++, into low-level machine language. Some compilers output assembly language which is then converted to machine language by a separate assembler. A compiler must first separate the statements of the source code from one another before it can translate them. Each statement must then be translated by evaluating its expressions according to the grammar. Both of these steps use parsing.

variable

An object with an identifier. It follows that a variable has all the following attributes.

1. A contiguous region of storage
2. An address
3. A type
4. A value
5. A name
6. A scope
7. A lifetime
8. A storage class (automatic, static, extern, or register).