Chapter 3 Functions and Pointers

Chapter 3 Functions and Pointers
?This chapter continues the discussion of the
C++ kernel language, focusing on functions,
pointers, and arrays.
3.1 Functions
?A problem in C++ can be decomposed into
subproblems, each of which can be either
coded directly or further decomposed. This
is the method of stepwise refinement.
?Some functions, are provided by libraries.
Others can be written by the programmer.
3.1.1 Function Invocation
?A C++ program is made up of one or more
functions, one of which is main(). Program
execution always begins with main ().
?When program control encounters a
function name, the function is called, or
invoked.
?Demo on page 62: bell.cpp
3.2 Function Definition
?The C++ code that describes what a
function does is called the function
f u n c t i on
definition.
de f i n i t i on .
Its form is:
function header
f u n c t i on h e ade r
{
statements
s t at e m e n t s
}
3.2 Function Definition
?The function header is:
type name
t y pe n am e
( parameter-declaration-list)
par am e t e r - de c l ar at i on - l i s t )
?Sometimes the parameters in a function
definition are called formal parameters
f or m al par am e t e r s
to
emphasize their role as placeholders for
actual values that are passed to the function
when it is called.
?parameters in C++ are call-by-value.
c al l - by - v al u e .
?Demo on page 63: bellmult1.cpp
3.3 The return Statement
?The return
statement is used for two purposes.
?immediately passed back to the calling environment.
?the value of the expression is returned to the calling
environment
?A return
statement has one of the following two
forms:
?return;
?return
expression
e x p r e s i o n
;
?Demo on page 64: min_int.cpp
3.4 Function Prototypes
?A
function prototype is a function
declaration, but not a function definition.
?By explicitly declaring the return type and
the list of argument types, strong typechecking
and assignment-compatible
conversions for functions are possible in
C++.
3.4 Function Prototypes
?The function prototype
has the following
general form:
type
t y pe
name(argument
n am e ( ar gu m e n t
-declaration-list)
- de c l ar at i on - l i s t )
;
?The argument-declaration-list
ar gu m e n t - de c l ar at i on - l i s t
is either
empty, or a single declaration, or a comma
separated list of declarations. If a function
has no parameters, the keyword void may
be used.
3.4 Function Prototypes
?C++ uses the ellipsis symbol ( . . . ) to mean
an argument list that is unspecified. The
stdio.h function printf() is declared as the
prototype:
int printf(const char* cntrl_str, ...);
3.4 Function Prototypes
?Demo on page 66: add3.cpp
?function prototype
?expression converted to return type
?function definition
?optionally include arguments variable names
3.5 Default Arguments
?A formal parameter can be given a default
argument.
?Demon on page 68: def_args.cpp
3.6 Overloading Functions
?The usual reason for picking a function
name is to indicate the function's chief
purpose.
?Sometimes various functions are used for
the same purpose.
3.6 Overloading Functions
?Overloading
is using the same name for multiple
meanings of an operator or a function. The
meaning selected depends on the types of the
arguments used by the operator or function.
?Demo on page 69: avg_arr.cpp
?How overloaded function is invoked?
?The compiler chooses the function with matching types
and arguments.
?The signature matching algorithm
s i g n a t u r e m a t c h i n g a l g o r i t h m
gives the rules for
performing this.
3.7 Inlining
?C++ provides the keyword i n l i ne to
preface a function declaration when the
programmer intends the code replacing the
function call to be inline.
?Demo on page 70: inline_t.cpp
?Macro expansion
M ac r o e xpan s i on
is a scheme for placing
code inline that would normally use
function call.
?Demo on page 71: inline_t.cpp
3.7 Inlining
?One reason for all the parentheses is to
avoid precedence mistakes, as would occur
in the following:
#define SQR(x) x*x;
?
y=SQR(t+8);
3.8 Scope and Storage Class
?The kernel language has two principal
forms of scope: local scope
l oc al s c ope
and file scope.
f i l e s c ope .
?Local scope is scoped to a block.
?File scope has names that are external (global).
?Demo on page 72: scope_t.cpp
?In C++, the scope of an identifier begins at
the end of its declaration and continues to
the end of its innermost enclosing block.
3.8.1 The Storage Class auto
?Every variable and function in C++ kernel
language has two attributes: type
t y p e
and storage class.
s t o r a g e c l a s .
?The four storage classes are automatic, external,
register, and static, with the corresponding
keywords:
?auto
?extern
?register
?static
?A
compound statement with declarations is a
block.
b l o c k .
3.8.2 The Storage Class register
?The storage class register tells the compiler
that the associated variables should be
stored in high-speed memory registers,
provided it is physically and semantically
possible to do.
?The storage class register
is of limited
usefulness. It is taken only as advice
adv i c e
to the
compiler.
3.8.3 The Storage Class extern
?One method of transmitting information
across blocks and functions is to use
external variables.
?The keyword extern
is used to tell the
compiler to "look for it elsewhere, either in
this file or in some other file."
3.8.3 The Storage Class extern
?External variables never disappear.
?Information can be passed into a function
two ways: by external variables and by the
parameter mechanism.
?Demo on page 75: circle3.cpp
3.8.4 The Storage Class static
?Static declarations have two important and
distinct uses.
?The more elementary use is to allow a local
variable to retain its previous value when the
block is reentered.
?The second and more subtle use is in
connection with external declarations, and will
be discussed in the next section.
3.8.4 The Storage Class static
?Demo on page 76: stat_tst.cpp
?static variable is not reinitialized
?it provides a privacy
p r i v a c y
mechanism that is very
important for program modularity.
3.8.4 The Storage Class static
?Note that in C++
C +
systems that have
namespaces this mechanism can be replaced
by anonymous namespaces.
?In C++,
C + ,
both external variables and static
variables that are not explicitly initialized
by the programmer are initialized to zero by
the system.
?In contrast, automatic and register variables
usually are not initialized by the system.
3.8.5 Linkage Mysteries
?Multi-file programs require proper linkage.
3.8.5 Linkage Mysteries
?Linkage to C code is possible using the
form:
extern "C"
{ code or included file
c ode or i n c l u de d f i l e
}
?Linkage to other languages beside C is
system-dependent.
3.9 Namespaces
?C++ encourages multi-vendor library use.
This motivates the addition to ANSI C++ of
a namespace
n am e s pac e
scope:
namespace
LMPinc
{
class puzzles {
?
} ;
class toys
{ . . . } ;
. . . . .
}
3.9 Namespaces
?The namespace identifier
n am e s pac e i de n t i f i e r
can be used as
part of a scope resolved identifier. This has
the form:
?namespace_id
n am e s pac e _d
:
:
: id
i d
?There is also a using
declaration that lets a
client have access to all names from that
namespace. For example:
using namespace
LMPi
nc
;
toys top; //
LMPi
nc
: : toys
3.9 Namespaces
?Demo on page 78: namespac.cpp
?namespaces can be used to provide a unique
scope replacing the use of static global
declarations. This is done by an anonymous
namespace definition, as in:
namespace
{ int
count
= 0;
} //count i s unique here
//count i s available i n the rest of the f i l e
void chg_cnt(int
i)
{ count
= i
; }
?The new ANSI conforming library headers
will no longer use the .h
suffix.
3.10 Pointer Types
?C++ pointers
C + poi n t e r s
are used to reference variables
and machine addresses.
?Pointers are used in programs to access
memory and manipulate addresses.
p
= &i;
// the address of object i
p
= 0;
// a special sentinel value
p
= static_cast
<
int
>(1507)
; // an absolute address
3.10.1 Addressing and
Dereferencing
?The dereferencing
or indirection
operator *
is
unary, and has the same precedence and right-toleft
associativity as the other unary operators.
int
i
= 5 , j;
int
*
p
= & i ; //pointer i n i t to address of i
cout
<< *
p
<< 'I
= i stored a t
" << p
<< endl
;
j
= p; / / illegal pointer not convertible to integer
j
= *
p
+ 1; //legal
p
= &j; //p points to j
3.10.2 Pointer-Based Call-by-
Reference
?In this section, we describe how the
addresses of variables can be used as
arguments to functions so the stored values
of the variables can be modified in the
calling environment, thus simulating callby-
reference.
?Demo on page 80: call_ref.cpp
?These pointers are passed call-by-value
?parameter is pointer
?access variables out of function
3.10.2 Pointer-Based Call-by-
Reference
?Call-by-Reference Using Pointers
?1. Declare a pointer parameter in the function
header.
?2. Use the dereferenced pointer in the function
body.
?3.
Pass an address as an argument when the
function is called
3.11 The Uses of void
?The keyword void is used as the return type
of a function not returning a value.
?A
more important use is to declare the
generic pointer
ge n e r i c poi n t e r
type-pointer to void.
3.11 The Uses of void
?A further use of void
given as the parameter
list in a function declaration means the
function takes no arguments.
?int
foo
();
?int
foo(void
);
3.11 The Uses of void
?Any pointer type can be converted to a
generic pointer of type void
*
.
?Other pointer conversions include:
?the name of an array is a pointer to its base
element;
?the null pointer value can be converted to any
type;
?the type "function returning T"
can be
converted to pointer to function returning T.
3.12 Arrays and Pointers
?An array is a data type that is used to
represent a sequence of homogeneous
values.
?Demo on page 82: sum_arr1.cpp
3.12.1 Subscripting
?Assume that a declaration of the form
int i, a[size];
?we may write a [expr] , where expr is an
integral expression, to access an element of the
array. We call expr a subscript, or index, of a.
?The value of a C++ subscript should lie in the
range 0 to size - 1.
?An array subscript value outside this range
often causes a run-time error.
3.12 .2 Initialization
?Arrays can be initialized by a commaseparated
list of expressions enclosed in
braces.
?An array declared with an explicit initializer
list and no size expression is given the size
of the number of initializers.
3.1 3 The Relationship between
Arrays and Pointers
?An array name by itself is an address, or
pointer value,
v al u e ,
and pointers and arrays are
almost identical in terms of how they are
used to access memory.
?A pointer is a variable that takes addresses
as values. An
array name is a particular
fixed address that can be thought of as a
constant pointer.
3.1 3 The Relationship between
Arrays and Pointers
?Example code
const int N=100;
int a[N],*p;
p=a;
p=&a[0];
p=a+1;
p=&a[1];
?Demo on page 85: sum_arr2.cpp
3.1 3 The Relationship between
Arrays and Pointers
?In many ways, arrays and pointers can be
treated alike, but there is one essential
difference.
?Arrays are constants.
?Note that sizeof
s i z e o f
(a)
( a )
and sizeof
s i z e o f
(p)
( p )
are different.
?The first expression is the size of the entire array,
?while the second is the size of a pointer expression.
3.14 Passing Arrays to Functions
?As a notational convenience, the compiler
allows array bracket notation
br ac ke t n ot at i on
to be used in
declaring pointers as parameters.
?Demo on page 86: sum_arr3.cpp
3.15 Reference Declarations and
Call-by-Reference
?Reference declarations declare the identifier to be
an alternative name, or alias, for an object
specified in an initialization of the reference, and
allow a simpler form of call-by-reference
parameters.
int
n;
int
&
nn
= n //
nn
i s alternative name for n
double a[10]
;
double& last
= a[9]; / / last is an alias for a[9]
3.15 Reference Declarations and
Call-by-Reference
?Declarations of references that are
definitions must be initialized, and are
usually initialized to simple variables.
?The initializer is an lvalue expression,
which gives the variable's location in
memory.
3.15 Reference Declarations and
Call-by-Reference
?The following definitions are used to
demonstrate the relationship of pointers,
dereferencing, and aliasing.
3.15 Reference Declarations and
Call-by-Reference
?Demo on page 88: sim_call.cpp
?Demo on page 89: greater.cpp
3.16 Assertions and Program
Correctness
?Assertions are program checks for correctness that,
if violated, force an error exit.
?add precondition
?add postcondition
?Demo on page 90: order.cpp
?The precondition assertion in place_min () guarantees
that a nonnegative number of elements will be searched.
?The postcondition in main () checks that the minimum
element was found and placed in the correct position.
3.1 7 Strings: The char* Convention
?The C and C++ communities have "agreed"
to treat the type char
c h ar
*
*
as a form of string
s t r i n g
type.
?The understanding is that these strings will
be terminated by the char value zero, and
that the cstring
c s t r i n g
(
(
string.h
s t r i n g. h
on older systems)
package of functions will be called on this
abstraction.
3.1 7 Strings: The char* Convention
?Some Functions in the
cstring
c s t r i n g
Library
iraybLr
?size_t
strlen(const
tsceronn
char
*
s) ;
?Computes the string length.
?char
*
strcpy(charc
tscrayhp(s1, const char
rn
*
s2);
?Copies the string s2 into sl. The value of sl is
returned.
?int
strcmp(const
tscropmn
char
*
s l , const char
ltscaohrn
*
s2);
?Returns an integer that reflects the lexicographic
comparison of s l and s2. When the strings are
the same zero is returned. When s l is less than
s2, a negative integer is returned. When s2 is less
than s l , a positive integer is returned.
3.1 7 Strings: The char* Convention
?Demo on page 92-93: str_func.cpp
3.18 Multidimensional Arrays
?C++ allows arrays of any type, including
arrays of arrays.
?A
k-dimensional array has a size for each of
its k dimensions.
3.19 Free Store Operators new and
delete
?The unary operators new
and delete
are
available to manipulate free store.
?Free store is a
system-provided memory
pool for objects whose lifetime is directly
managed by the programmer.
?The programmer creates the object by using
new
and destroys it by using delete.
3.19 Free Store Operators new and
delete
?In C++, operator new
is used in the
following forms:
new type-name
teaynwpm
new type-name
initializer
iterzanl
new type -
name[expression
seraoxnnpm
]
3.19 Free Store Operators new and
delete
?The operator delete has the following forms:
delete
expression
e xpr e s i on
delete []
expression
e xpr e s i on
?Demo on page 95: dynarray.cpp
?dynamically allocated array
?use delete to free store.
3.20 Pragmatics
?When function arguments are to remain
unmodified, it can be efficient and correct
to pass them const call-by-reference.
3.20 Pragmatics
?For variables that are not to be changed and
whose memory requirements are small, callby-
value is usual.
?ANSI C allows the narrowing conversion
from void* to an arbitrary pointer type, but
C++ does not.
3.20 Pragmatics
?The widening conversion from specific to
generic pointer type is safe and allowed
implicitly.
?The narrowing conversion from generic to
specific pointer type is potentially unsafe
and system-dependent.
?reinterpret_caste<>
3.20.2 Replacing s t a t i c extern
Declarations
?Anonymous namespaces (see Section 3.9,
"Namespaces," on page 78) should be used
to provide a unique scope replacing the use
of static global declarations.
namespace{int seed = 0; } //makes a unique name
void srand(int i){ seed = i ;} //unique::seed
Summary
?1. function deceleration and definition
?2. In C++, a function cannot be used until it is
declared.
?3. A
return statement is used to exit a function.
?4. An array is a data type that is used to represent
a sequence of homogeneous values.
?5. The four storage classes are automatic, external,
register, and static.
Summary
?6. C++ pointers are used to reference variables and
machine addresses.
?7. Reference declarations allow an object to be
given an alias or alternate name.
?8. The declaration void
*
is a generic pointer type.
?9. In a function definition, a formal parameter that
is declared as an array is actually a pointer.
?10. The unary operators new
and delete
are
available to manipulate free store.