This is a chapter about arrays and vectors in c++

Chapter 6 of C++ How to Program, 9/e
©1992-2017 by Pearson Education, Inc. All Rights Reserved.

 Develop and maintain a large program by constructing it
from small, simple pieces, or components.
◦ divide and conquer.
 Emphasize how to declare and use functions to facilitate
the design, implementation, operation and maintenance
of large programs.
 Function prototypes and how the compiler uses them to
convert the type of an argument in a function call to the
type specified in a function’s parameter list, if necessary.
 Simulation techniques with random number generation.
 C++’s scope rules.
©1992-2017 by Pearson Education, Inc.
All Rights Reserved.

 How C++ keeps track of which function is currently
executing, how parameters and other local variables
of functions are maintained in memory and how a
function knows where to return after it completes
execution.
 Function overloading.
 Function templates.
 Recursion.

 C++ programs are typically written by combining
“prepackaged” functions and classes available in the C++
Standard Library with new functions and classes you
write.
 The C++ Standard Library provides a rich collection of
functions.
 Functions allow you to modularize a program by
separating its tasks into self-contained units.

 A function is invoked by a function call, and when the
called function completes its task, it either returns a
result or simply returns control to the caller.
 An analogy is the hierarchical form of management
(Figure 6.1).
◦ A boss (similar to the calling function) asks a worker (similar to
the called function) to perform a task and report back (i.e.,
return) the results after completing the task.
◦ The boss does not know how the worker performs its tasks.
◦ The worker may also call other workers, unbeknownst to the
boss.
 This hiding of implementation details promotes good
software engineering.
 The relationship does not need to be hierarchical, but
often it is, which makes it easier to test, debug, update
and maintain programs.

 Sometimes functions are not members of a class.
◦ Called global functions.
 The <cmath> header provides a collection of functions that
enable you to perform common mathematical calculations.
 All functions in the <cmath> header are global functions—
therefore, each is called simply by specifying the name of the
function followed by parentheses containing the function’s
arguments.

 Some math library functions are summarized in
Fig. 6.2.
◦ In the figure, the variables x and y are of type
double.

 In this section, we create a user-defined function called
maximum (Fig. 6.3) that returns the largest of its three int
arguments.

 For a function not defined in a class, you must either
define the function before using it or you must declare
that the function exists, as we do in line 7 of Fig. 6.3:
◦ int maximum(int x, int y, int z); // function prototype
 This is a function prototype, which describes the
maximum function without revealing its implementation.
 A function prototype is a declaration of a function
◦ tells the compiler the function’s name, its return type and the
types of its parameters.
 This function prototype indicates that the function
returns an int, has the name maximum and requires
three int parameters to perform its task.
 The function prototype is the same as the first line of the
corresponding function definition (line 20), but ends
with a required semicolon.

 When compiling the program, the compiler uses
the prototype to
◦ Ensure that maximum’s first line matches its prototype.
◦ Check that the call to maximum contains the correct
number and types of arguments, and that the types of
the arguments are in the correct order.
◦ Ensure that the value returned by the function can be
used correctly in the expression that called the function.
◦ Ensure that each argument is consistent with the type of
the corresponding parameter.
 If the arguments passed to a function do not match the types
specified in the function’s prototype, the compiler attempts to
convert the arguments to those types.

 Multiple parameters are specified in both the
function prototype and the function header as a
comma-separated list, as are multiple arguments
in a function call.

 In a function that does not return a result (i.e., it has
a void return type), we showed that control returns
when the program reaches the function-ending right
brace.
 You also can explicitly return control to the caller by
executing the statement
◦ return;

 A function prototype is required unless the function
is defined before it’s used.
 When you use a standard library function like sqrt,
you do not have access to the function’s definition,
therefore it cannot be defined in your code before
you call the function.
 Instead, you must include its corresponding header
(<cmath>), which contains the function’s prototype.

 The portion of a function prototype that includes the
name of the function and the types of its arguments is
called the function signature or simply the
signature.
◦ Signature does not specify the function’s return type.
 The scope of a function is the region of a program in
which the function is known and accessible.

 An important feature of function prototypes is argument
coercion
◦ forcing arguments to the appropriate types specified by the
parameter declarations.
◦ These conversions occur as specified by C++’s promotion rules.

 The promotion rules indicate how to convert between
types without losing data.
 The promotion rules apply to expressions containing
values of two or more data types
◦ also referred to as mixed-type expressions.
 The type of each value in a mixed-type expression is
promoted to the “highest” type in the expression.

 Figure 6.4 lists the arithmetic data types in order
from “highest type” to “lowest type.”
 Converting values to lower fundamental types can
result in incorrect values.
 Therefore, a value can be converted to a lower
fundamental type only by explicitly assigning the
value to a variable of lower type or by using a cast
operator.

 The C++ Standard Library is divided into many portions,
each with its own header file.
 The header files contain the function prototypes for the
related functions that form each portion of the library.
 The header files also contain definitions of various class
types and functions, as well as constants needed by
those functions.
 A header file “instructs” the compiler on how to
interface with library and user-written components.
 Figure 6.5 lists some common C++ Standard Library
header files, most of which are discussed later in the
book.

 The element of chance can be introduced into computer
applications by using the C++ Standard Library function
rand.
 The function rand generates an unsigned integer
between 0 and RAND_MAX (a symbolic constant defined
in the <cstdlib> header file).

 The value of RAND_MAX must be at least 32767—the
maximum positive value for a two-byte (16-bit) integer.
 For GNU C++, the value of RAND_MAX is 2147483647; for
Visual Studio, the value of RAND_MAX is 32767.
 If rand truly produces integers at random, every
number between 0 and RAND_MAX has an equal chance
(or probability) of being chosen each time rand is called.

 The function prototype for the rand function is in
<cstdlib>.
 To produce integers in the range 0 to 5, we use the
modulus operator (%) with rand:
 rand() % 6
◦ This is called scaling.
◦ The number 6 is called the scaling factor. Six values are
produced.
 We can shift the range of numbers produced by
adding a value.

 To show that the numbers produced by rand occur
with approximately equal likelihood, Fig. 6.7
simulates 60,000,000 rolls of a die.
 Each integer in the range 1 to 6 should appear
approximately 10,000,000 times.

 Prior to C++14, you’d represent the integer value
60,000,000 as 60000000 in a program.
 To make numeric literals more readable, C++14
allows you to insert between groups of digits in
numeric literals the digit separator ' (a single-quote
character)
◦ 60'000'000 represents the integer value 60,000,000.

 Executing the program of Fig. 6.6 again produces
exactly the same sequence of values.
◦ Repeatability is an important characteristic of rand.
◦ Can help with testing and debugging.
 rand generates pseudorandom numbers.
◦ a sequence of numbers that appears to be random.
◦ sequence repeats itself each time the program executes.

 Once a program has been debugged, it can be
conditioned to produce a different sequence of
random numbers for each execution.
 This is called randomizing and is accomplished
with the C++ Standard Library function srand.
◦ Takes an unsigned integer argument and seeds rand to
produce a different sequence of random numbers for
each execution.

Seeding the Random Number Generator with srand
 Figure 6.8 demonstrates function srand.

 To randomize without having to enter a seed
 srand(static_cast<unsigned int>(time(0)));
 Causes the computer to read its clock to obtain the
value for the seed.
 Function time (with the argument 0 as written in
the preceding statement) returns the current time
as the number of seconds since January 1, 1970, at
midnight Greenwich Mean Time (GMT).
 The function prototype for time is in <ctime>.

 To produce random numbers in a specific range use:
◦ type variableName = shiftingValue + rand() % scalingFactor;
 shiftingValue is equal to the first number in the
desired range of consecutive integers
 scalingFactor is equal to the width of the de-sired
range of consecutive integers.

 According to CERT, function rand does not have
“good statistical properties” and can be
predictable, which makes programs that use rand
less secure (CERT guideline MSC30-CPP).
 C++11 provides a new, more secure library of
random-number capabilities that can produce
nondeterministic random numbers that can’t be
predicted.
 Such random-number generators are used in
simulations and security scenarios where
predictability is undesirable.
◦ New capabilities are located in the C++ Standard
Library’s <random> header.

 For flexibility based on how random numbers are
used in programs, C++11 provides many classes
that represent various random-number
generation engines and distributions.
◦ An engine implements a random-number generation
algorithm that produce pseudorandom numbers.
◦ A distribution controls the range of values produced by
an engine, the types of those values (e.g., int, double, etc.)
and the statistical properties of the values.
 uniform_int_distribution evenly distributes
pseudorandom integers over a specified range of
values.

Rolling a Six-Sided Die
 Figure 6.10 uses the default_random_engine and the
uniform_int_distribution to roll a six-sided die.
◦ default_random_engine object named engine.
◦ Its constructor argument seeds the random-number
generation engine with the current time.
◦ If you don’t pass a value to the constructor, the default
seed will be used and the program will produce the same
sequence of numbers each time it executes.
◦ randomInt—a uniform_int_distribution object that
produces unsigned int values (as specified by <unsigned
int>) in the range 1 to 6 (as specified by the constructor
arguments).
◦ The expression randomInt(engine) returns one unsigned
int value in the range 1 to 6.

 The notation <unsigned int> indicates that
uniform_int_distribution is a class template.
 In this case, any integer type can be specified in the angle
brackets (< and >).
 In Chapter 18, we discuss how to create class templates
and various other chapters show how to use existing class
templates from the C++ Standard Library.
 For now, you should feel comfortable using class template
uniform_int_distribution by mimicking the syntax shown
in the example.

 The portion of the program where an identifier can
be used is known as its scope.
 This section discusses
◦ block scope
◦ global namespace scope

 Identifiers declared inside a block have block scope, which
begins at the identifier’s declaration and ends at the
terminating right brace (}) of the enclosing block.
◦ Local variables have block scope, as do function parameters.
 Any block can contain variable declarations.
 In nested blocks, if an identifier in an outer block has the
same name as an identifier in an inner block, the one in the
outer block is “hidden” until the inner block terminates.
 The inner block “sees” its own local variable’s value and
not that of the enclosing block’s identically named variable.

 An identifier declared outside any function or class
has global namespace scope.
◦ “known” in all functions from the point at which it’s
declared until the end of the file.
 Function definitions, function prototypes placed
outside a function, class definitions and global
variables all have global namespace scope.
 Global variables are created by placing variable
declarations outside any class or function definition.
Such variables retain their values throughout a
program’s execution.

Scope Demonstration
 The program of Fig. 6.11 demonstrates scoping
issues with global variables, automatic local
variables and static local variables.

 To understand how C++ performs function calls, we
first need to consider a data structure (i.e., collection
of related data items) known as a stack.
 Analogous to a pile of dishes.
◦ When a dish is placed on the pile, it’s normally placed at the
top—referred to as pushing.
◦ Similarly, when a dish is removed from the pile, it’s
normally removed from the top—referred to as popping.
 Last-in, first-out (LIFO) data structures—the last
item pushed (inserted) is the first item popped
(removed).

Function-Call Stack
 One of the most important mechanisms for computer science
students to understand is the function call stack (or program
execution stack).
◦ supports the function call/return mechanism.
◦ Also supports the creation, maintenance and destruction of each
called function’s automatic variables.

Stack Frames
 Each function eventually must return control to the
function that called it.
 Each time a function calls another function, an entry is
pushed onto the function call stack.
◦ This entry, called a stack frame or an activation record,
contains the return address that the called function needs
in order to return to the calling function.

Automatic Local Variables and Stack Frames
 When a function call returns, the stack frame for the
function call is popped, and control transfers to the return
address in the popped stack frame.
Stack Overflow
 The amount of memory in a computer is finite, so only a
certain amount of memory can be used to store activation
records on the function call stack.
 If more function calls occur than can have their activation
records stored on the function call stack, an a fatal error
known as stack overflow occurs.

Function Call Stack in Action
 Now let’s consider how the call stack supports the
operation of a square function called by main (Fig. 6.12).
 First the operating system calls main—this pushes an
activation record onto the stack (shown in Fig. 6.13).
 The activation record tells main how to return to the
operating system (i.e., transfer to return address R1) and
contains the space for main’s automatic variable (i.e., a,
which is initialized to 10).

 Function main—before returning to the operating
system—now calls function square in line 12 of Fig. 6.12.
 This causes a stack frame for square (lines 16–18) to be
pushed onto the function call stack (Fig. 6.14).
 This stack frame contains the return address that square
needs to return to main (i.e., R2) and the memory for
square’s automatic variable (i.e., x).

 After square calculates the square of its argument, it
needs to return to main—and no longer needs the memory
for its automatic variable x. So square’s stack frame is
popped from the stack—giving square the return location
in main (i.e., R2) and losing square’s automatic variable.
 Figure 6.15 shows the function call stack after square’s
activation record has been popped.

 Two ways to pass arguments to functions in many
programming languages are pass-by-value and pass-by-
reference.
 When an argument is passed by value, a copy of the
argument’s value is made and passed (on the function
call stack) to the called function.
◦ Changes to the copy do not affect the original variable’s
value in the caller.
 To specify a reference to a constant, place the const
qualifier before the type specifier in the parameter
declaration.

 With pass-by-reference, the caller gives the called function
the ability to access the caller’s data directly, and to modify
that data.
 A reference parameter is an alias for its corresponding
argument in a function call.
 To indicate that a function parameter is passed by
reference, simply follow the parameter’s type in the
function prototype by an ampersand (&); use the same
convention when listing the parameter’s type in the
function header.
 Figure 6.17 compares pass-by-value and pass-by-reference
with reference parameters.

 References can also be used as aliases for other
variables within a function.
 Reference variables must be initialized in their
declarations and cannot be reassigned as aliases to
other variables.
 Once a reference is declared as an alias for another
variable, all operations supposedly performed on
the alias are actually performed on the original
variable.

 To specify that a reference parameter should not be
allowed to modify the corresponding argument,
place the const qualifier before the type name in
the parameter’s declaration.
 string objects can be large, so they (and objects in
general) should be passed to functions by reference.

 Functions can return references, but this can be
dangerous.
 When returning a reference to a variable declared in
the called function, the variable should be declared
static in that function.

This is a chapter about arrays and vectors in c++

More Related Content

Similar to This is a chapter about arrays and vectors in c++ (20)

Recently uploaded (20)

This is a chapter about arrays and vectors in c++