COP 2000 Glossary

The list of terms below is provided to supplement or elaborate on the terms and definitions provided in the course textbook. Students are advised to also review the textbook to develop a fuller understanding of these and other important terms related to each chapter. The terms below are ordered based on their logical position in the learning process while studying programming rather than in alphabetical order. As such, the list can be read as a whole to help review the concepts introduced in the related chapters. Note that many of the terms also contain links to other terminology in this glossary or other locations. Readers can find any term on this page quickly by using their browser's Find on this page feature (activated by the keystoke combination Ctrl+F in most broswers).

JUMP TO CHAPTER: 1 2 3 4 5 6 7 8 9 10

Chapter 1 Terms

In the most general sense, the word object is used in computer science to mean simply "thing". For example, a window is an object. An icon is an object. A scrollbar is an object. And so on. Every visual element that we see on a computer screen is an object. Within the context of computer programming, an "object" is defined more formally as a data structure consisting of properties (such as size, color, value) and methods (sets of actions the object can perform). A stored item of data (such as a price) is an example of a simple object. A program is an example of a more complex object. For a more comprehensive discussion of what a programming object is, see Chapter 13 of your textbook about "OOP" (Object Oriented Programming).
A class is a framework or skelton from which objects (see above) can be created. Classes contain specifications about how data will be stored within an object and about any processes (called methods) that the object will able to perform. For more information, see Chapter 13 of your textbook.
The term data type refers to a system of classification used to discuss different styles of data with common properties. Examples of data types include: text, graphics (pictures and drawings), audio (music and voice), video (movies), and instructions (programming commands), to name a few. (For a full explanation of the concept of data type, see the web page Data Types in the C++ Programming Language.)
Primative data types are those that are part of a programming language and can be easily manipulated by it without requiring a programmer to construct special programming objects for that purpose. (See Abstract Data Types below). Some of the primitive data types in C++ are: bool, char, double, and int.
Abstract data types are those that are constructed from primitive data types into more complex data structures such as arrays, binary trees, linked lists, vectors, etc.
A character is a type of data that involves only a single symbol such as: 'A', '4', '!', or ' ' (a blank space). Storage locations for character data are declared using the keyword char.
Text is the term used by most people to describe the form of data consisting of characters (see above) such as: letters, numerals, and punctuation.
A number is a form of data consisting of values, quantities or amounts, such as: ages, distances, prices, weights, etc. Numbers should not be confused with "numerals" (see below) which are symbols (as distinguished from the values they represent).
A numeral is a symbol - a specific piece of text (see above) data, also known as a "digit". Numerals should not be confused with "numbers" (see above) which are values instead of symbols.
Binary is a word with two meanings in programming. The first and most common meaning relates to the numbering system known as "Base-2" in which all values are represented using only "two (bi) numerals (nary) ". The second meaning relates to the use of operators such as the minus sign (-) in a formula. When the symbol appears between two items (such as the values 5 and 2 in the formula 5-2), it is referred to as a "binary operator". When the symbol appears preceding only one item (such as the value 2 in the formula -2), it is referred to as a "unary operator".
Bits are binary (see above) digits (0 or 1) that represent the settings of individual switches or circuits inside a computer (OFF or ON). Data is represented as standardized patterns of bits. For example, the number (value) 5 is "coded" as 00000101, and the numeral (symbol) '5' is "coded" as 00110101.
A byte is the unit of measure of storage space used to represent a single character. In American desktop computers, there are typically 8 bits in a byte.
ASCII is an acronym for the "American Standard Code for Information Interchange"; a computer language for representing characters on computers as a pattern of binary (see below) values. The original ASCII standard defined 128 7-bit patterns for coding characters. That standard was later expanded to represent 256 8-bit patterns and renamed ASCII-8, although the term ASCII is typically used nowadays to indicate the 256 8-bit standard.
A control code is an item within the character data type that affects output but is not visually represented as a symbol. Examples of control codes are: backspace, carriage return, line feed, tab, and the EOF (End of File) character. For a complete list of the 32 ASCII control codes, see the [ASCII Table Documentation from Basement Computing].
Decimal is another word with two meanings in programming. The first and most common meaning relates to the numbering system known as "Base-10" in which all values are represented using ten digits (0-9). The second meaning relates to the use of a decimal point when writing numbers with fractional parts, such as the value one half in 8.5 or one tenth in 4.1. Numbers written containing a decimal point are often referred to as "decimal numbers"; however this is technically incorrect, as it implies that the numbers are also written using the Base-10 numbering system (which may not be the case). A more precise way to talk about numbers that contain fractional parts is to call them "floating point numbers" or more simply "floats".
Octal is a numbering system known as "Base-8" in which all values are represented using eight digits (0-7). Each place in the octal numbering system represents a power of 8 (8⁰=1, 8¹=8, 8²=64, etc.) C++ distinguishes octal numbers from decimal numbers by writing them with a leading zero. For example, the octal number representing the value twenty is written as 024. The leading zero indicates an octal number (and appears in the 64's place). The digit 2 appears in the 8's place; and the digit 4 appears in the 1's place. So 2 values of 8 plus 4 values of 1 equal twenty.
Hexadecimal is a numbering system known as "Base-16" in which all values are represented using sixteen possible digits (0-9, then A-F to represent 11-15 respectively). Each place in the hexadecimal numbering system represents a power of 16 (16⁰=1, 16¹=16, 16²=256, etc.) Very large numbers, such as memory addresses, can be written with only a few digits in the hexadecimal numbering system because each place (digit column) represents larger and larger values in comparison to base-10 (decimal). C++ distinguishes hexadecimal numbers from decimal numbers by writing them with a leading zero followed by a lowercase 'x'. For example, the hexadecimal number representing the value one hundred seventy two is written as 0xAC. The leading 0x indicates a hexadecimal number. The digit A (10) appears in the 16's place; and the digit C (12) appears in the 1's place. So 10 values of 16 plus 12 values of 1 equal 172.
Source code is instructions written in a high-level language such as C++ recorded as text for later translation into object code (machine language). Files containing C++ source code typically end with a filename extension of ".cpp".
Object code is machine language instructions that resulted from a compiling operation being performed. Files containing C++ object code typically end with a filename extension of ".obj". Such files cannot be loaded into memory and run until a linker/loader program prepares them for that event by linking them together with any other necessary object code files.
Executable code is machine language instructions that resulted from a linking/loading operation being performed, in which one or more object code files are merged into a complete working program, ready to load into memory and execute. In the Windows® environment, files containing executable code typically end with a filename extension of ".exe".
A compiler is a program that translates source code into object code (machine language instructions). Compilers also typically provide a text editor for writing source code and a linker/loader that combines all of the pieces (object code files) of a program together to create an executable program file. Some more sophisticated compilers also include diagnostic features to assist in finding program errors. Compilers with all of these features are known as integrated development environments (IDE's).
A statement is a unit of instruction in source code, similar to a "sentence" in English, except that C++ statements are terminated with a semicolon (;) rather than a period. C++ source code is simply a set of statements. Similar to a sentence in English, a statement can extend over more than one line of type and is terminated only by the proper punctuation (a semicolon).
A block is a group of statements (see above) which are enclosed in braces { } to designate that they should always be interpreted as a single unit.
A segment is a collection of adjacent "statements". When providing examples of programming source code, authors often list only a few relevant statements, rather than an entire program. This small list is a "segment of code".
Syntax is the set of grammatical and structural rules used in a language to construct "statements" (see above).
A header file is a file containing useful blocks of pre-written source code that can be added to your source code using the "#include" compiler directive. Header files typically end with a filename extension of ".h".
A delimiter is any character used to separate individual items of data. For example, in English, we use periods as sentence delimiters. We use the colon as the delimiter between hours, minutes and seconds when writing times. The slash is often used as a delimiter when writing a date to separate month, day and year.
Whitespace is any character or group of characters that a program normally interprets as a delimiter, including: spaces ( ), form feeds (\f), new-lines (\n), raw carriage returns (\r), horizontal tabs (\t), and vertical tabs (\v). In C++ source code, all of these characters are interpreted as the same unless they are quoted. In other words, one space is interpreted the same as three blank lines.
Hardcopy is permanent output that is produced on a physical material (such as paper) that a user could hold and carry away.
Softcopy is temporary output that a user could not grasp and carry away because it is produced in an intangible form on a device such as a screen.
A reserved word is a word within the vocabulary of a programming language that cannot be used within source code for any purpose other than the meaning originally intended for it by the authors of the language. For example, in C++ the command word return cannot be declared a programmer as an identifier. (See also the related, but different terms "keyword" and "standard identifier" that follow.)
A keyword is a word within source code that has a specific meaning, but only within a limited context. (See also the related, but different term "reserved word" above.)
A identifier is a label used to represent a programming object, such as a variable or a function. Identifiers are "case-sensitive" in C++, meaning that upper and lowercase appearances of the same label are treated as being different identifiers. Identifiers that are declared within a block or a function are local to that block or function, meaning that they will not be recognized outside of it. Identifiers that are declared outside of all blocks and functions are global, meaning that they will be recognized within all statements.
A standard identifier is an identifier (see above) similar to a reserved word, except that it is not an official part of a language's vocabulary. Typically these are identifiers given to functions or objects such as cout that are so useful that they have been included as library functions within most compiler programs.
A location is a unit of space in computer memory used to hold data. Locations have three properties:
1. Content is whatever data the location holds.
2. An address is a numeric designation (like the number on a mailbox) that distinguishs one storage location from another. Prior to the use of identifiers, programmers had to remember the address of stored data rather than its identifier. In C++, addresses are referred to by preceeding a identifier with an ampersand symbol (&) as in &X which refers to the address of storage location X as opposed to its contents.
3. The size of a location is based on the data type of its contents.
An identifier can be "bound" (tied or connected) to a variable (see below) using a definition statement).
A variable is a storage location used to hold a value that is expected to be different during each program execution. The identifiers used to access variables are properly referred to as either variable labels or variable names, although many people improperly use the shorter term "variable" to refer to the identifier.
To allocate means to set aside or reserve a storage location for an object. Storage is allocated using a definition statement.
To assign means to store data within a storage location. Data is most often assigned using the assignment operator (=) in an expression. Note that the = symbol is not used in the C++ language to test for equality. That is accomplished with the == relational operator.
To initialize means to assign (see above) data into a location for the first time.
A declaration is a statement within program source code that indicates an identifier for a programming object (such as a variable or a function) and specifies it properties such as its data type. (See also the related, but different term "definition" that follows.) The term "declaration" is used both as a noun indicating a statement within source code or as a verb indicating the action performed by that statement.
A definition is a statement within program source code that both allocates storage space for an object and specifies its properties (which could include an initial value). For example, the statement
int N=2;
allocates a storage location intended to store an integer and assign the value 2 as its contents. (See also the related, but different term "declaration" above.) The term "definition" is used both as a noun indicating a statement within source code or as a verb indicating the action performed by that statement.
A problem statement is analysis documentation that defines the purpose and restrictions of a program in sufficient detail that the program can be analyzed and designed without more facts. The problem statement for a simple program could be as short as a single sentence. The problem statement for a sophisticated program could be an entire multi-page report. For more information about this item of documentation, read the Problem Solving Example on this web site.
A structure diagram is graphic documentation used in top-down design that helps to describe the hierarchical relationship between a module and its various sub-modules. (See Chapter 6.)
A symbolic constant list is analysis documentation that formally lists all symbolic constants used in a program. It contains columns indicating each symbolic constant's: identifier, description, data type, value, processing (usage), and output destination. For more information about this item of documentation, read the Problem Solving Example on this web site.
A variable list is analysis documentation that formally lists all variables to be used in a program's source code. It contains columns indicating each variable's: identifier, description, data type, source, processing (usage), and output destination. For more information about this item of documentation, read the Problem Solving Example on this web site.
A sample softcopy is analysis documentation that precisely demonstrates all softcopy (video or other intangible output) required of a program. For more information about this item of documentation, read the Problem Solving Example on this web site.
A sample hardcopy is analysis documentation that precisely demonstrates all hardcopy (printed (tangible) output) required of a program. For more information about this item of documentation, read the Problem Solving Example on this web site.
An algorithm is a recipe or finite list of steps to follow in solving a well-defined task, written in the language of the user (i.e. in human terms). Algorithms can be wriiten in a variety of formats, including: outlines, flowcharts (see below), or pseudocode. For more information about these items of documentation, read the Problem Solving Example on this web site.
A flowchart is a graphic algorithm in which program steps are drawn as a sequence of standarized shapes, each representing an action that can be take by a processor. These shapes are connected by "flow arrows" that indicate the "flow of control" through the flowchart. For more information about flowcharts, view the PDF file about Logical Control Structures on this web site.
Pseudocode is an algorithm written in English, but as clearly stated logical items that can be easily translated by a programmer into C++ or other high-level programming languages. For an example of pseudocode, read the Problem Solving Example on this web site.
A desk check is a manual test of a program algorithm that is performed prior to writing the source code. It must follow the algorithm exactly and typically produces two items of documentation: a tracing chart showing what values are stored in memory during program execution, and test outputs (test softcopy and test hardcopy) showing what output the algorithm will produce. Test output should not be confused with sample output, which defines the output objectives. Sample output shows what you want to produce. Test output shows what your algorithm will produce. For more information about these items of documentation, read the Problem Solving Example on this web site.

Chapter 2 Terms

A preprocessor directive (a.k.a. compiler directive or just directive) is an instruction in a C++ source code file that is used to give commands to a compiler about how the compilation should be performed (as distinguished from C++ language statements that will be translated into machine code). Compiler directives are not statements, therefore they are not terminated with semicolons. Compiler directives are written starting with a # symbol immediately in front of (touching) the command word, such as
#include <iostream>
The body of a function contains the statements that represent the steps in the algorithm. These are enclosed inside of braces { }.
A literal is an actual piece of data (sometimes referred to as simply a "value") such as the number 5 or the character 'A', as distinguished from an identifier (label representing a data object). It is often referred to as a constant because it does not change from one run of a program to another, as a variable does.
A named constant is actually a variable that has been designated as read-only (after its initialization), so that any data stored there is effectively treated as a constant (see "literal" above). This is accomplished by placing the keyword const ahead of the data type in a declaration statement.
Symbolic Constants (often called constant macros) are similar to named constants (see above) in that they are used in place of values that are expected to be the same during each execution of a program, but that might need to be changed someday. However, "symbolic constants" are not storage locations. Instead, they are aliases (nicknames) used in place of literals in source code that are replaced by a compiler (during source code transalation) with the literals that they represent. Symbolic constants are defined within C++ source code using the "#define" directive at the top of the source code (to allow easy location and revision later.) Note that directives are not terminated with a semicolon.
Integer (not "interger") data is a numeric type of data involving a whole number (ie. it cannot have a fractional portion). An example of an integer literal is 5 (written without a decimal point or quotes). See section 2.6 of your textbook for specific information about a variety of integer data types and the proper notation to declare them.
int - the most common reserved word used in a declaration statement for integer data (see above), typically allowing a data range of -2,147,483,648 through +2,147,483,647.
Floating point data is a numeric type of data that can have a fractional portion. Mathematicians call such data a "real number". An example of a floating point constant is 12.567 (written without a decimal point) or 0.5 (always write at least one digit on both sides of the decimal point). The most common type identifiers for floating point data are float (for typical numbers) and double (for numbers such as 1.2345678901234E+205 that involve extreme precision or magnitude).
float - the most common reserved word used in a declaration statement for low precision (6 or fewer significant digits) floating point data (see above).
double - the most common reserved word used in a declaration statement for high precision (greater than 6 significant digits) floating point data (see above).
char is the reserved word used in source code to declare character data.
String data is a type of data involving multiple characters (symbols) such as words or sentences. The C++ language does not implement strings as a primitive data type. Instead it provides two abstract methods for representing strings:
1. String objects can be constructed from a string class as long as the source code contains the compiler directive:
```
#include <string>
```
  The reserved word string (all lowercase) is used in C++ to declare data as string class. A string object named TITLE could be defined using the statement:
```
string TITLE;
```
2. An array of separate characters is known in C++ as a C-string. Statements used in C++ to declare a C-string are discussed in Chapter 10.
Boolean data (named in honor of English mathematician and philosopher [George Boole]) is a primitive type of logical data involving only two values: True and False. (See the reserved word bool below.) Early versions of C++ (and many other languages) represented the true and false values using the integer values 1 for true and 0 for false. Modern C++ recognizes the words true and false as Boolean values. C++ and many other languages will treat 0 as false and any non-zero integer value as true.
bool is the reserved word used in C++ source code to declare Boolean data.
A logic error is caused by a mistake in the steps used to design the program algorithm.
A syntax error is caused by a grammatical error in the language of the source code
A run-time error occurs when a program encounters commands it cannot execute; for example dividing a number by zero.
Comments can be included within C++ source code, enclosed in the symbols /* and */. The inclusion of comments in source code neither causes the program to run more slowly, nor causes the object code to take up more space, because comments are not translated.
Blank spaces in C++ code act as separators and are not allowed in an identifier. Multiple blank spaces are treated the same as one, except in string constants (text inside of double quotes).
Character literals must be enclosed in apostrophes ('), a.k.a. "single quote marks".
String literals must be enclosed in quotes ("), a.k.a. "double quote marks"..
Escape sequences are special strings typed within C++ output statements to produce characters that would otherwise be interpreted as having special meaning to a compiler. For example, to output a double quote mark (") in a string literal, precede the quote mark with a backwards slash (\). To output the message
His name is "Joe".
use
cout << "His name is \"Joe\".";
A cursor is a symbol such as a vertical bar ("|"), underscore ("_"), or small filled box (" ") that is displayed on a computer screen (sometimes blinking) to indicate where the next output action will take place.
Carriage returns within C++ source code are ignored during the compilation, except within reserved words, identifiers, or string literals where they are not allowed. To produce a carriage return within output on the screen, you must include the escape sequence \n inside of double quotes. For example, to output the word "Hello" followed by a carriage return on the screen, use
cout << "Hello\n"
Each statement is C++ is normally terminated with a semicolon ( ; ). Note that compiler directives are not considered to be C++ source code and so they are not terminated with a semicolon.
include is a compiler directive in C++ that is used to indicate that a unit of pre-defined program code (such as the header file "iostream") should be linked to your program when it is compiled.
define is a compiler directive in C++ that is used to indicate that a symbolic constant is being used in your program in place of a constant value and that the value should be used in place of the symbolic constant when translating the source code into machine language.
{ (open brace) is the symbol used in C++ to start a block of statements.
} (close brace) is the symbol used in C++ to end a block of statements.
A console is a computer terminal used to enter or view data. Early computers had simple monochrome consoles (similar to the image on the right) that where incapable of displaying graphic data such as images or text using fonts. These consoles could display only plain monospaced text. Modern operating systems provide users with a program that imitates the screens of early consoles in a black and white window. For simplicity sake, all programs written in this class will be written to use only a console windows; so they will be limited to using only plain text.
A stream object is an object used in C++ to manipulate streams of data, typically strings of characters.
The characters << can be used in C++ as a stream insertion operator to send streams of data (typically characters) to the cout object. (See also the >> stream extraction operator discussed in Chapter 3.)
cout is a stream object (see above) used in C++ to display output on a console. It is used in combination with the << stream insertion operator as in the statement below:
```
cout << "The amount to pay is:" << PAYMENT << endl;
```
An expression (also discussed in Chapter 3) is a written formula. Expressions consist of operands (such as literals or variable names) and operators (such as + or -).
An operation is an action that can be performed by a computer such as assignment, arithmetic, or comparison.
An operator is one or more symbols used in source code to indicate an action to be taken by a computer such as assignment, arithmetic, or comparison.
An operand is an item of data (such as a literal or variable) that is acted upon by an operator (such as + or -).
Unary operators are operators that involve data from only one operand. In the statement X = -5; the minus sign acts as a unary operator and operates on a single operand (the literal 5).
Binary operators are operators that involve data from two operands. In the statement X = A/B; the slash acts as a binary operator and operates on a pair of operands (the variables A and B).
An arithmetic operator is an operator that performs mathematical operations (such as addition, subtraction, multiplication, division, or modulus) to produce a numeric result. The most frequently used arithmetic operators are: + (addition), - (negation or subtraction), * (multiplication), / (division), and % (modulus, a.k.a. remainder).

Chapter 3 Terms

A buffer is a storage area inside a computer which is used to transfer data between devices. You can think of a buffer as a data "waiting room". For example, keystrokes that are typed on a keyboard are stored in a keyboard buffer until a program is ready to process them. When a disk file is read, its data is typically read in blocks of hundreds or thousands of characters at a time and stored in a disk buffer until a program has use for some of them.
The characters >> can be used in C++ as a stream extraction operator to extract streams of data (typically characters) from the cin stream object. (See also the << stream insertion operator discussed in Chapter 2.)
cin is a stream object used in C++ to store input from a keyboard into a variable and then advance the cursor to the next line when the user presses the Enter key. It is used in combination with the >> stream extraction operator as in the second statement below:
```
cout << "What is the price? ";
cin >> PRICE;
```
A member function (a.k.a. a method) is a function that is defined as part of an object to allow the object to perform actions. Member functions are recognized by their use in source code following and separated from a function's identifier by a period. For example, the get member function of the cin object (see above) is accessed as: cin.get() (also note the use of parentheses to denote get as a function).
cin.get is a "member function" (see above) of the cin stream object used in C++ to store single character input from a keyboard into a character variable. It is useful in reading whitespace characters that can be misinterpreted by the cin object as delimiters separating multiple items of input. For information about techniques for inputting literal whitespace characters, read the web page entitled Console Input of Character Data in C++.
cin.ignore is a member function of the cin stream object used in C++ to skip single or multiple characters of input in the keyboard input buffer to avoid having them processed. It is useful in avoiding whitespace characters that can be misinterpreted by the cin object as delimiters separating multiple items of input.
getline is a function used in C++ to store keyboard input containing whitespace characters into a single string variable rather than treating the whitespaces as delimiters between separate strings. It typically is used in combination with the cin stream object and requires the inclusion of the following compiler directive to be used in a program::
```
#include <string>
```
A prompt is a message that is output (typically on a computer screen) by a program to ask or instruct a user to enter some data (typically at the keyboard). For example, the phrases "How old are you (in years)?" or "Enter your age (in years):" might be displayed by a program to urge a user to enter required input data. The term "prompt" is also often used as a verb to indicate the action of displaying such a message, as in "The program will prompt the user to enter...".
An echo is an action in a program when an item of input data is bounced back to an output device as proof that the input was received. There is no direct connection between a computer's keyboard and its screen; so there is no guaranty that a character will appear on a screen when a user presses its key on the keyboard. However, most programs automatically echo a character for each keystroke, so that the user can track the input action.
Review the term expression (discussed in Chapter 2).
An arithmetic expression is one which performs arithmentic operations (such as addition, subtraction, multiplication, division, or modulus) on numeric operands (such as literals or variables) to produce a numeric result. An example of an arithmetic expression is X+3.
Order of Precedence is a term used to describe which operations precede others when groups of operators appear in an expression. For example, C++ compilers see the expression A+B/C as A+(B/C) as opposed to (A+B)/C . The division operation will preceed the addition because division has a higher order of precedence. For more information on expressions and order of precedence, see the web page entitled Expressions & Operators in C++.
Associativity (a.k.a. "fixity") of an operator is a property that specifies how operators of the same precedence are grouped in the absence of parentheses. For example, C++ compilers evaluate the expression A*B/C as (A*B)/C as opposed to A*(B/C) because the associativity of multiplication and division (both of the same precedence) is "left" (meaning performed from left to right). The multiplication operation will be done first because it is left of the division operation. On the other hand, C++ compilers evaluate the expression X=Y=2 as X=(Y=2) as opposed to (X=Y)=2 because the associativity of the assignment operation is "right" (meaning performed from right to left). The assignment of 2 to Y will be done first because it is right of the assignment of X.
Library Functions (discussed as predefined functions in Chapter 6) are functions with a broadly applicable purpose that are written and stored for use in future programs. Sometimes groups of these functions are organized by the type of purpose they perform and stored in header files as function libraries.
Arguments are items of data that are given to a function to be used in producing its result. Any C++ statement that uses a function must include the function's identifier followed by a parenthesized list of arguments that are being provided for the function to do its job. If the function requires no arguments, an empty set of parentheses must still be written following the function name.
An exponent is a value used in an arithmetic expression to indicate a numeric power to which a number is being raised. For example, when writing an expression to "square" (raise to the second power) the number 4, the value 2 is the exponent. Unlike some other programming languages, C++ does not have an operator for expotentiation (raising a number to a power). Instead it provides a library function for this purpose. The C++ expression to raise 4 to the second power is pow (4.0, 2.0) , with 2.0 as the exponent.
Type Casting is the process of promoting or demoting data within a data type. For example, if you try to divide two integer variables A and B and store the result in a floating point variable C, the result will have any decimal fraction truncated (chopped-off) because both operands are integers. To prevent this, type cast either of the operands as floats before the division operation is performed, as in either of the following examples:
```
   C = static_cast<float>(A) / B;
   C = A / static_cast<float>(B);
```
Trying to type cast the result instead of the operands would be pointless because the truncation would have already taken place. So it would be ineffective to try:
```
   C = static_cast<float>(A / B);
```
For more information about type casting, read the [Type Casting page at CPlusPlus.com].
A combined assignment operator is an arithmetic operator that performs both an arithmetic operation (such as addition, subtraction, multiplication, division, or modulus) to an existing operand and then assigns the result back into that operand. The combined arithmetic operators are: += (increase by), -= (decreased by), *= (multiplied by), /= (divided by), and %= (replaced by remainder). For example, the expression N+=2 means the same as N=N+2.
The term output formatting refers to the manner in which visual output is displayed. It includes such issues as spacing, alignment, precision, presence of decimal points, etc. C++ controls output formatting through the use of the stream object cout and a collection of optional stream manipulators as described in section 3.7 of your textbook.
endl is a stream manipulator used with the cout stream object to specify that a line of output should end. It peforms the same action as inserting the special escape sequence \n into a string being output. For example, the statement:
```
   cout << "My Program" << endl;
```
and the statement:
```
   cout << "My Program\n";
```
will both display the words "My Program" one a single line and then carriage return to the next line.
The term field has a few meanings in computer science. In the most general sense, it means simply "single item of data" or "one fact". When speaking about output, the term "field"refers to the area of the screen in which output appears. C++ programmers can specify a limited area of the screen to be used to display a number using the stream manipulator setw() (see below).
setw() is a stream manipulator used with the cout stream object to specify the desired minimum width of an output field for the next item in the output stream. If the output item is larger than the width specified, the setw manipulator is overriden and the entire item is displayed. If the output item is smaller than the width specified, the setw manipulator will align item to the right side of the output field (padding the unused positions with blank spaces) unless overriden by the use of the left (alignment) stream manipulator. For example, the statement:
```
   cout << setw(8) << 123.45 << endl;
```
will display the value 123.45 in a width of 8 characters with (2 spaces padded in front of the digit 1).
The term significant digits describes the quantity of digits in a written number that appear before and after the decimal point (combined). The term precision is often used to mean the same thing. However, the term "precision" is also used in some situations to indicate the quantity of digits that appear after (to the right of) the decimal point in a written number. In C++ cout statements, output precision is controlled by using the setprecision() (see below) stream manipulator ahead of the value to be displayed in the output stream. When the setprecision() manipulator is used in combination with the fixed() manipulator, it controls only the quantity of digits that appear after the decimal point.
setprecision() is a stream manipulator used with the cout stream object to contol output precision. For example, the statement:
```
   cout << setprecision(4) << 246.7912 << endl;
```
will display the value 246.8 (rounded at the 4th digit position). When used with the setw() manipulator, a low value specified for the setprecision() manipulator can cause the computer to use scientific notation in the output of the value. When used with the fixed manipulator, the setprecision() manipulator changes to specify the number of digits to the right of the decimal point, rather than the total on both sides of it. The effects of the setprecision() manipulator are persistent, affecting all items in the output stream following its use.
fixed is a stream manipulator used with the cout stream object to output digits in "fixed point" (referred to by some as "decimal") notation. For example, the statement:
```
   cout << setprecision(2) << fixed << 123.9182 << endl;
```
will display the value 123.92 (rounded at the 2nd digit position right of the decimal point). The effects of the fixed manipulator are persistent, affecting all items in the output stream following its use.
left is a stream manipulator used with the cout stream object to horizontally align all following output to the left side of the output field by padding the unused positions with blank spaces. Note that the default horizontal alignment for the C++ cout stream object is "right", regardless of data type.
right is a stream manipulator used with the cout stream object to horizontally align all following output to the right side of the output field by padding the unused positions with blank spaces. Note that the default horizontal alignment for the C++ cout stream object is "right", regardless of data type.
showpoint is a stream manipulator used with the cout stream object to pad numeric output with trailing zeros until all digits specified by the setprecision() manipulator have been output (even for numbers with fewer digits than specified). For example, the statement:
```
   cout << setprecision(6) << showpoint << 123.4 << endl;
```
will display the value 123.400 (padding the last 2 digit positions of the 6 specified with spaces). The effects of the showpoint manipulator are persistent, affecting all items in the output stream following its use.

Chapter 4 Terms

Branching is the act of breaking out of the normal sequence of steps in an algorithm to allow an alternative process to be performed or to allow the repetition of process(es).
Control Structures are organized groups of steps that are followed in a specific order, including:
- Sequence: a control structure in which the "flow of control" follows only one path - from one step to another - without branching. The use of the sequential control structure is indicated in C++ by the use of a block (a.k.a. "compound statement") in which a series of statements is enclosed between the symbols { and }.
- Selection: a control structure in which alternative paths (referred to as branches or legs) may be followed based on the result of a condition. When any leg of a selection structure is completed, flow of control must come to closure, branching forward to the end of the structure.
- Repetition: a control structure in which steps may be repeated based on the result of a condition. For more information on repetition structures, see Chapter 5. Note: repetition control structures are often referred to as loops.
For more information about control structures, view the PDF file Logical Control Structures on this web site.
A condition is a situation or state that ultimately evaluates to be a Boolean (true or false) value. Control structures and programming statements that are capable of branching, depend on testing action to determine a condition (such as X equals 0). Conditions can be Boolean values such as true or false, or they can be the result of relational expressions or logical expresssions.
Relational operators are those used to evaluate the relationships between items of data, including:
- == for Equal to, the opposite of which is written in C++ as != (or not equal to). Note that the symbol = is not used to test for equality. Instead it is the assignment symbol in C++.
- > - Greater than, the opposite of which is written in C++ as <= (less than or equal to).
- < - Less than, the opposite of which is written in C++ as >= (greater than or equal to).
Relational expressions (also known as relational tests) describe conditions using expressions (such as X==A+B) involving relational operators that compare items of data (possibly including literals, variables or arithmetic expressions) and produce a Boolean (true or false) result.
Logical operators such as && for "and", || for "or" and ! for "not" are those used to combine conditions into logical expressions such as (X==0 && Y>10) to produce a single Boolean (true or false) result.
A ternary operator is a rare operator that uses two symbols to operate on three operands. (See conditional operator below).
A conditional operator is a rare ternary operator used as method to implement a simple two leg selection structure with a single statement known as a conditional expression. This statement can be used as a more compact method for coding a simple two leg selection structure than the typical combined if and else statements. For example, given an integer variable named I and a string object named MSG, a selection structure that would normally be coded as
```
   if (I<0) MSG="Negative";
   else MSG="Non-negative";
```
could be written in a single compact statement as
```
   I<0 ? MSG="Negative" : MSG="Non-negative";
```
The term nesting describes the situation of having one control structure occur on a leg of another control structure; for example, having an entire selection structure take place on a leg of a different selection structure, or having a loop inside another loop. Nested structures do not have to be of the same type. A selection can be nested inside a loop for example.
Ordinal data is a type of data in which all of the values within the set are known and in a predictable order. Ordinal data types include: all integer data types and char data, but not floating point or string data. For more information see the Ordinal Data page.
if is a reserved word in C++ used to implement the conditional test and the statement (or braced block) on the true leg of a selection structure. For example, to code an algorithm step that reads "if variable I is less than zero, then display the word 'Negative'", the C++ statement would be:
```
   if (I<0) cout << "Negative";
```
Note that if statements can be paired with else statements (see below) to implement selection structures with two legs, or they can be nested to implement selection structures with more than two legs.
else is a reserved word in C++ used to implement only the statement (or braced block) on the false leg of a selection structure. Note that an else statement can be used only in conjustion with a preceding if statement and does not repeat the conditional test from that statement. For example, to code an algorithm step that reads "if variable I is less than zero, then display the word 'Negative', otherwise display 'Non-negative'", the pair of C++ statements would be:
```
   if (I<0) cout << "Negative";
    else cout << "Non-negative";
```

Chapter 5 Terms

A loop is another name for a repetition control structure (see Chapter 4) in which program steps can be repeated based on the result of a condition. The parts of a loop are as follows:
- Loop Body: the step(s) to be repeated - represented in C++ source code as a statement or braced block. Each time that the body is performed is referred to as a pass (or iteration).
- Loop Entry: the first statement of a loop body (see above).
- Loop Test: the position in a loop where the condition that controls "passage" (repetition of a loop's steps) or exit from it is tested.
- Loop Exit: the position in a loop where the flow of control is passed to the next structure in the program. This is typically the false leg of the loop's conditional test.
The design of loops involves three major considerations:
- Control Structure: defining the order of the steps involved in the loop with particular attention given to the position of the statement that tests the condition which allows the "flow of control" to either branch backwards to the loop's entry or to "exit" the loop by branching forwards to the next step in the program's algorithm. The position of the conditional test in a loop can be influenced by the needs of the task being performed, but it is often a matter of preference by the program designer. Three positions are possible:
  - Pretest (or Leading Decision) structures - where you first test a condition to see if you should perform a loop's body and then perform it, after which you branch back to repeat the loop test. This structure is often called the while-do structure, but this term should be avoided because many programming languages use the words while and do in different ways. In the C++ language, pretest loops are coded as follows:
```
   while (condition)
 {block-of-statements-to-perform;}
```
  - Posttest (or Trailing Decision structures - where you first perform a loop's body and then test a condition to see if you should branch back to repeat it. This structure is often called the do-while structure, but this term should be avoided because many programming languages use the words while and do in different ways. In the C++ language, posttest loops are coded as follows:
```
   do {block-of-statements-to-perform;}
   while (condition);
```
  - Midtest (or Middle Decision structures - where you first perform some a step(s) in a loop's body and then test a condition to see if you should exit the loop before finishing the remaining step(s) in the body. This structure should be avoided because it is error-prone. For this reason, many programming languages have no code to implement it. C++ offers the statements break and continue as described in section 5.12 of your textbook. But these should be used only with great care.
- Method of Control: defining the data upon which the conditional test is based. The tests for exit from a loop are typically based on the value of a single variable referred to as the loop's control variable. The source of the data stored in this variable determines the methods of control. The most common methods are:
  - Counting control (also known as internal control) - where the condition that controls the exit from the loop is based entirely upon the value of a variable known as a counter that is initialized and altered by the programmer. All loops that use counting control have at least four parts:
    - Initialization - a step in which the counter (control variable) has its first value assigned
    - Body - the steps that are to be repeated in the loop
    - Increment/Decrement - the step the either increases or decreases the counter by a fixed value
    - Test - the statement that tests a condition which will allow exit from the loop
  - Sentinel control (also known as external control) - where the condition that controls the exit from the loop is based entirely upon the value of a variable that is obtained from input read from the user or a file.
- Boundary Values: The values in variables at the moment of entry into and exit from a loop are often critical to its success and should always be considered during loop design.
Accumulation is the process of building a running sub-total through repeated adjustments to a variable. An example of accumulation is: T = T + N; where the variable T "accumulates" the value in variable N. The value in N is added to the value in T and the result is stored back in T replacing its original values.
Increment and Decrement Operators are the symbols ++ and -- used either preceeding or trailing a counter. In the expression Y=++X the value of X is increased by one and then the new value of X is assigned to Y. In the expression Y=X++ the original value of X is assigned to Y and then the value of X is increased by one. Increment and decrement operators can be used only on ordinal data such as integers or characters.
A variable used to indicate a specific situation or status within a program is called a flag. Flags are typically set to a value of false (zero) to indicate that a situtation does not exist. When a situation is detected (usually by a test) within a program, the variable is set to a true (non-zero) value (often 1). Later tests of the flag's value will indicate whether the situation exists or not.
To open a file means to establish a connection between a program and a file to allow the access of data. Before a C++ program can open a file, you must load a header file named fstream using the preprocessing directive:
```
   #include <fstream>;
```
That file contains code that allows programmers to define file stream objects that can be manipulated to access data files using one of three data types:
- ifstream: an input file stream for reading data from a file.
- ofstream: an output file stream for writing data to a file.
- fstream: a bi-directional file stream, used for either read or write access.
The following source code would open a data file named "mydata.txt" using an input file stream object (arbitrarily) named "inputFile" for future input statements:
```
   ifstream inputFile;
   inputFile.open("mydata.txt");
```
Input data could then be read from the file using its file stream object in a manner similar to the use of the cin stream object (introduced in Chapter 3). The statement below would read a value using its file stream object "inputFile" into an integer variable named N:
```
   inputFile >> N;
```
The following source code would open a data file named "mydata.txt" using an output file stream object (arbitrarily) named "outputFile" for future output statements:
```
   ofstream outputFile;
   outputFile.open("mydata.txt");
```
Output data could be written to the file using its file stream object in a manner similar to the use of the cout stream object (introduced in Chapter 2). The statement below would write from an integer variable named N to its file stream object "outputFile":
```
   outputFile << N;
```
File stream objects can be both defined and opened in a single statement using code as follows:
```
   ifstream inputFile("mydata.txt");
```
or
```
   ofstream outputFile("mydata.txt");
```
A path is a description of the storage device and folders that must be read by an operating system to reach a file. For example, the path to a file named "mydata.txt" in a folder named "Temp" on a disk named "C:" would be written in Windows as "C:\Temp\mydata.txt". Because the C++ language interprets the character "\" as the start of an escape sequence, C++ programmers must remember to "escape" that character when referring to it by writing it as "\\". As such, the path to the file mentioned earlier would be written in C++ as: "C:\\Temp\\mydata.txt".
To close a file means to sever a connection between a program and a file being accessed. The following source code would close an output file being manipulated by a file stream object named "outputFile":
```
   outputFile.close();
```

Chapter 6 Terms

Top-Down Design is an analysis method in which a major task is sub-divided into smaller, more manageable, tasks called functions (see definition below). Each sub-task is then treated as a completely new analysis project. These sub-tasks may be sufficiently large and complex that they also require sub-division, and so on. The document that analysts use to represent their thinking related to this activity is referred to as a structure diagram. For more information and an example of such a diagram, see the web notes on Analysis & coding of a task involving multiple functions.
Procedural Abstraction is an analysis method in which a modular unit of a program (known in C++ as a function (see definition below) is mentioned in an algorithm without being defined. This approach allows programmers to stated that a task will be performed at some point in a program without worrying about the details, which are defined elsewhere.
Functions (a.k.a. procedures, modules, or subroutines) are blocks of source code that perform steps or sub-steps in a program. Every C++ program contains at least one function. Its name must be "main" (all lowercase) and program execution always begins with it. Any function can call (execute) other functions. A function must be declared in the source code ahead of where it is called. This can be accomplished by writing the source code for the entire child (called) function ahead of its parent (calling) function, or by writing a "function prototype" statement (see below) ahead of the calling function.
Predefined Functions are the same thing as library functions (discussed in Chapter 3).
A function header is the first line of a function definition that specifies the function's data type and identifier and any parameters it will receive. A function header is not a complete statement. It is only the start of one that defines the function. So a function header must not be terminated with a semi-colon.
A child function is one that is subordinate to (called by) another function.
When one function calls another, the calling (currently active) function is referred to as the parent function and the called (about to be executed) function is known as a child (see above) function.
The scope of an identifier defines the range within program source code where the identifier has meaning. Identifiers that are declared within a function are local to that function, meaning that they will not be recognized outside of it. Identifiers that are declared outside of all functions are global, meaning that they will be recognized within all functions.
Call: The action of one function activating or making use of another functions is referred to as calling. When a function is called, the address of the next program instruction (know as an instruction pointer) is stored by the processor to retain its position in memory. After the child function has completed execution, the instruction pointer is retrieved to allow the processor to jump back to the next instruction in the parent procees. In the C++ language, a function must be declared in the source code ahead of the statement that calls it.
A function prototype is a single declarative statement (rather than an entire function definition) that is placed ahead of a calling function in the source code to declare a child function''s identifier before it is used. The entire function definition must still be written later in the code, but may appear at a more convenient position following the calling function. A function prototype is simply a reproduction of a function header that is terminated with a semi-colon.
Parameters are values that are passed (sent) between functions. The C++ statement that calls a function must include the function's identifier followed by a parenthesized list of parameters that are being passed into the function. These parameters are referred to as actual parameters because they are the actual values being provided by the parent (calling) function. Actual parameters are often also referred to as arguments. In the C++ source code where a function is declared, a function header is written to declare the function identifier and to declare any other identifiers (known as formal parameters) that will be used inside of the function to represent any data being passed into it. Formal parameters do not have to be identical to the actual parameters used in the calling statement, but must match in quantity and be compatible in data type. Functions can be used to produce a value in much the same way that a formula does. When a child function sends a value back to its calling parent function, that action is referred to as returning the value. Most languages offer a few different ways to return values, depending on the quantity of values to be returned. One method is to store the value in the function's identifier, which because it is typically declared globally, can be accessed from anywhere in the parent function. The keyword return is used for two purposes in C++: (1) to place a value (its argument) in the function's identifier, and (2) to immediately terminate a function and pass control back to its parent function. A function that returns a value through its identifier is called by a statement that treats the function name as a data object (having an action performed upon it). On the otherhand, a function that does not return a value through its identifier is called by a statement that treats the function name as a verb (a command starting the statement). For more information, read the notes about Functions and Parameter Passing.
A parameter list is analysis documentation that formally lists all parameters (see above) to be used in a program's source code. It contains columns indicating each variable's: identifier, description, data type, source, processing (usage), and output destination. For more information about this item of documentation, read An Example of Documenting a Program Using Parameter Passing on this web site.
A default argument is an item of data that is passed into a function if no actual argument is provided in the calling statement. Default arguments are specified in the formal parameter list of a function using the assigment operator (=).
The term static (in general) indicates something that is firm or unchanging. A static local variable is a local variable that persists from one execution of a function to another, unlike normal local variables which are destroyed when a function terminates.
A reference variable is an identifier being used as an alias for another variable (typically outside of the current function's scope). The use of a reference variable as a formal parameter allows any change to it to alter the value in its related actual parameter, unlike normal parameters which normally receive copies of the data from actual parameters, but do not allow changes to be sent back to them. The passage of data into a function via a reference variable is referred to as passage by reference. A reference variable is declared in the formal parameter list of a function by placing the symbol & (ampersand) immediately after the data type indicator (as in: int &). The blank space is optional. The data type indicated for the reference variable must match the data type of its related actual parameter. For example, the declaration for a reference variable named NICKNAME as an alias for an actual parameter of type int would be:
```
   int &NICKNAME;
```
In the declaration above, the identifier NICKNAME acts as a "reference to an integer". Although the ampersand (&) touches the identifier, it is not part of it. Note that the identifier is just NICKNAME, not &NICKNAME. This topic is closely relate to the terms in Chapter 9 about pointers.
To overload a function means to define more than one function with the same identifier. This allows us to use the same function name for more than one purpose. The compiler must determine which function to use from the context in the source code based on the quantity or data type of the actual arguments in the calling statement. Each overloaded function must have a unique formal parameter list. For example, you could define a function named QUARTER to divide a passed argument by 4. The passed argument could be either an integer or a float as long as you wrote one version of the function using a formal parameter of type int and another version of the function using a formal parameter of type float. The type of data returned by overloaded function does not have to be the same. The first function in the preceeding example could return an int, and the second function could return a float.

Chapter 7 Terms

A scalar is a simple type of storage in which one identifier relates to only one storage location.
An array is a type of storage in which one identifier relates to a block of storage locations, all of the same data type. Each individual storage location within an array is called an element. Each individual element within an array is referenced using a subscript, which is a numeral that follows the identifier enclose within brackets, such as X[5]. Arrays are often called subscripted variables. In the C++ language, array elements are numbered starting at zero. The element with the subscript value of zero is referred to as the bottom of the array. The element with the highest subscript value is referred to as the top of the array. The statement in C++ to declare an array of ten integer storage locations labeled N[0] through N[9] would be:
```
    int N[10];
```
Arrays can be any data type, but all elements of an array must be the same data type. The quantity of elements can be expressed as a literal (as shown in brackets above [10]) or using named constants or symbolic constants (as in the segment of code below):
```
    #define SIZE 10
    int N[SIZE];
```
An index is a value that is being used to indicate the position of a specific element within a data structure, such as an array. The term "index" is also used as a verb to indicate the action of using its value to indicate a position.
The elements within an array can be grouped into sets that can be referenced with separate subscripts. The quantity of subscripts that are used to index the sets is referred to as the dimension of the array. The examples of arrays discussed above have all been one-dimensional arrays, because they treat all of the elements within their arrays a single sets of data to be referenced with only a single subscript. A more complex two-dimensional array could be defined to represent a table of data where each row in the table was a set of elements. The array could then use one subscript to indicate the row of the table and a different subscript to index the column position. The statement to declare an array named T of five rows of three integer elements each would be:
```
    int T[5][3];
```
All elements of all sets of elements in an array must be the same data type. The quantity of elements can be expressed as literals (as shown above) or using named constants or symbolic constants (as in the segment of code below):
```
    #define ROWS 5
    #define COLS 3
    int T[ROWS][COLS];
```
A vector is special data type called a container that was defined as part of the Standard Template Library, a group of popular programmer defined data types and algorithms recognized by most modern compilers. Vectors are similar to arrays except that they do not require specification of the quantity of elements when they are defined and they can be dynamically allocated or otherwise manipulated using member functions that are automatically created with every defined vector. (See these in the next bulleted item below). Before using vectors, a programmer must include a header file named "vector", as in the preprocessor directive:
```
    #include <vector>
```
As with arrays, each individual storage location within a vector is called an element and each individual element is referenced using a subscript. And vector elements also are numbered starting at zero. The statement in C++ to declare a vector of ten integer storage locations labeled N[0] through N[9] would be:
```
    vector<int> N(10);
```
Note the use of parentheses () in the statement above around the vector size (10). Remember that array sizes are specified within brackets []. To declare the vector above with specifying its initial size, simply omit the parenthesized size, as in:
```
    vector<int> N;
```
Like arrays, vectors can be any data type, but all elements of a vector must be the same data type. The quantity of elements can be expressed as a literal (as shown in parentheses above (10)) or using named constants or symbolic constants (as in the segment of code below):
```
    #define SIZE 10
    vector<int> N(SIZE);
```
Each vector (see above) that is defined includes the following member functions:
- at returns the value of a vector element at specified subscript.
- capacity returns the maximum number of elements that may be stored in a vector without allocating additional memory. (Similar to the size member function below which reports memory usage rather than allocation)
- clear clears the vector of all its elements, removing the ability to reference them, but without deallocating the memory used by the vector, which is reserved for further growth of the vector).
- empty returns the Boolean value true if the vector is empty (ie. contains zero elements); otherwise returns false.
- pop_back removes the top (last) element from a vector, reducing its size by 1.
- push_back appends a new element to the top (end) of a vector (increasing its size by 1) and assigns the new element a value specified as this member function's argument.
- reverse reverses the order of the elements, in a vector.
- resize increases the size of a vector by the the number of elements specified as the first argument to this member function and initalizes the new elements to a value specified as its second argument.
- size returns the quantity of elements contained within a vector. (Similar to the capacity member function above which reports memory allocation rather than usage.)
- swap swaps the contents of the vector with a different vector, specified as this member function's argument.

Chapter 8 Terms

A target value is the value being sought in a search.
A hit is the event of finding a "target value" (see above) during a search.
A linear search is a simple search algorithm that uses a loop to sequentially step through an array, starting with its bottom element, and comparing each element's contents to the target value until it is found or the top element is processed.
A binary search is a fast search algorithm that can be used on sorted arrays. It starts by testing the middle element, using the results of that test to eliminate the half of the array that does not contain the target value. The process is then repeated on the remaining half, with the loop continuing until the target is found or there are no more elements left to search.
A bubble sort is a simple sorting algorithm that repeatedly steps through an array, comparing each pair of adjacent elements and swapping them if they are in the wrong order. The pass through the array is repeated until no swaps are needed, which indicates that the array is sorted. The algorithm gets its name from the way smaller elements "bubble" to the top element of the array.
A selection sort is a sorting algorithm that searches an array for the lowest unprocessed value and swaps its position with the bottom element. The process repeats, finding and swapping the next lowest unprocessed value with the next element up from the bottom. The process repeats until all values have been moved to their correct location.

Chapter 9 Terms

Reference is another term for identifier, a label that indicates a stored data object. The term "reference" is also used as a verb to indicate the act of using an identifier to indicate a stored data object.
A pointer is a special type of variable that is used to store the address of a data object (such as a variable) rather than its contents. There is a different type of pointer variable for each type of data. For example, a "pointer to an integer" is different data type than a "pointer to a float". Pointer varables are declared using the asterisk (star) symbol in front of the identifier to indicate that it is a "pointer variable". For example, the declaration for an integer pointer with an identifier of IPTR would be:
```
   int *IPTR;
```
In the declaration above, the data type is "pointer to an integer"; not just "pointer". Although the star touches the identifier, it is not part of it. The identifier is just IPTR, not *IPTR. It is a common practice by programmers to include the letters "PTR" (or just "P") at the end of the identifer when declaring pointers to help readers realize that they are pointers. Pointers should not be confused with reference variables mentioned with the terms in Chapter 6 about functions and parameter passing. For more information about pointers, read the page Pointers and Indirection.
Indirection (also called dereferencing) is the act of assigning a value referred to by a pointer's contents (a stored address) rather directly assigning those contents. For example, given integer variable named I containing the value 4 with an address of 2000, if an integer pointer named IPTR was (directly) assigned the address of I with the statement
```
   IPTR = &I;
```
the following statement could be used to indirectly assign the value in I to variable X:
```
   X = *IPTR;
```
For more information about indirection, read the page Pointers and Indirection.

Chapter 10 Terms

C-Strings data is a type of data that can hold multiple symbols. The C++ language does not have a primitive data type for storing strings, but can accomodate them using either string objects (as introduced in Chapter 2) or as arrays of characters. For example, the statement to declare an array of twenty character storage locations labeled S[0] through S[19] to hold a string of 20 symbols would be:
```
    char S[20];  /* Declare a string named S to hold no more than 20 characters */
```

String functions are functions that receive or produce string parameters. The C++ language offers a multitude of string functions in a library header file named "string" that must be included with your source code if you want to use them. The statement to do so would be:

    #include <string>

Some of the most popular string functions are:

Usage Example	Explanation of Purpose
`strlen(S)`	Return the length of the string S
`strcpy(T,"Source")`	Copies the string "Source" into the string (character array) T
`strcmp(A,B)`	Compares the contents of string A to string B and returns a: 0 if they are equivalent under ASCII rules, negative integer if string A precedes B, and positive value if string B precedes string A
`strcat(A,B)`	Concatenates (appends) string B onto the end of string A

The null character is a control code (non-visible character) used in C++ to note the end of a string. Most string functions (see above) use the null character to keep track of how many elements of a character array have been used to store a string. Programmers can indicate a null character by typing the escape sequence '\0' which is sometimes read aloud as "whack zero". Note the use of single quotes (apostrophes) to indicate a character literal.

JUMP TO CHAPTER: 1 2 3 4 5 6 7 8 9 10

PATH: Instructional Server> COP 2000>