fundamentals of programming -...
Post on 28-Mar-2020
11 Views
Preview:
TRANSCRIPT
Fall 2013
Instructor: Reza Entezari-Maleki
Email: entezari@ce.sharif.edu
Sharif University of Technology 1
Fundamentals of Programming Session 23
These slides have been created using Deitel’s slides
Outlines
C++
Inline Functions
References and Reference Parameters
Default Arguments
Classes and Objects
Defining a Member Function with a Parameter
Data Members, set Functions and get Functions
2
C++ improves on many of C’s features and provides
object-oriented-programming (OOP) capabilities that
increase software productivity, quality and reusability.
This section revisits the addition program of Fig. 2.8
and illustrates several important features of the C++
language as well as some differences between C and
C++.
C file names have the .c (lowercase) extension.
C++ file names can have one of several extensions, suchas .cpp, .cxx or .C (uppercase).
3
C++
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.
Figure 15.2 lists common C++ Standard Library
header files.4
Header Files
Implementing a program as a set of functions is good
from a software engineering standpoint, but function calls
involve execution-time overhead.
C++ provides inline functions to help reduce function call
overhead—especially for small functions.
The trade-off is that multiple copies of the function code
are inserted in the program (often making the program
larger) rather than there being a single copy of the
function to which control is passed each time the function
is called.
The compiler can ignore the inline- qualifier and
typically does so for all but the smallest functions.7
Inline Functions
Lines 4–6 are using statements that help us eliminate
the need to repeat the std:: prefix.
From this point forward, each C++ example contains one
or more using statements.
In place of lines 4–6, many programmers prefer to use
using namespace std;
C++ also provides type bool for representing boolean
(true/false) values.
The two possible values of a bool are the keywords trueand false.
10
Inline Functions …
Two ways to pass arguments to functions in many
programming languages are pass-by-value and pass-by-
reference.
This section introduces reference parameters—the first of
two means that C++ provides for performing pass-by-
reference.
A reference parameter is an alias for its corresponding
argument in a function call.
For example, the following declaration in a function header
int &count
when read from right to left is pronounced ―count is a
reference to an int.‖11
References and Reference Parameters
In the function call, simply mention the variable by name
to pass it by reference.
Then, mentioning the variable by its parameter name in
the body of the called function actually refers to the
original variable in the calling function, and the original
variable can be modified directly by the called function.
As always, the function prototype and header must agree.
Figure 15.5 compares pass-by-value and pass-by-reference
with reference parameters.
12
References and Reference Parameters …
References can also be used as aliases for other
variables within a function (although they typically are
used with functions as shown in Fig. 15.5).
For example, the code int count = 1; // declare integer variable countint &cRef = count; // create cRef as an alias for countcRef++; // increment count (using its alias cRef)
increments variable count by using its alias cRef.
Reference variables must be initialized in their
declarations, as we show in line 9 of both Fig. 15.6 and
Fig. 15.7, and cannot be reassigned as aliases to other
variables.15
References and Reference Parameters …
Returning references from functions can be dangerous.
When returning a reference to a variable declared in the
called function, the variable should be declared
static within that function.
Otherwise, the reference refers to an automatic variable
that is discarded when the function terminates; such a
variable is ―undefined‖ and the program’s behavior is
unpredictable.
References to undefined variables are called dangling
references.
18
References and Reference Parameters …
It’s not uncommon for a program to invoke a function
repeatedly with the same argument value for a particular
parameter.
In such cases, the programmer can specify that such a
parameter has a default argument, i.e., a default value to
be passed to that parameter.
When a program omits an argument for a parameter
with a default argument in a function call, the compiler
rewrites the function call and inserts the default value of
that argument to be passed as an argument in the
function call.19
Default Arguments
Default arguments must be the rightmost (trailing)
arguments in a function’s parameter list.
When calling a function with two or more default
arguments, if an omitted argument is not the rightmost
argument in the argument list, then all arguments to the
right of that argument also must be omitted.
Default arguments should be specified with the first
occurrence of the function name—typically, in the
function prototype.
If the function prototype is omitted because the function
definition also serves as the prototype, then the default
arguments should be specified in the function header.20
Default Arguments …
In C++, we begin by creating a program unit called a class tohouse a function.
A function belonging to a class is called a member function.
In a class, you provide one or more member functions thatare designed to perform the class’s tasks.
You must create an object of a class before you can get aprogram to perform the tasks the class describes.
That is one reason C++ is known as an object-orientedprogramming (OOP) language.
Messages are sent to an object. Each message is known as a
member-function call and tells a member function of the
object to perform its task.
This is often called requesting a service from an object.23
Classes and Objects
We begin with an example (Fig. 16.1) that consists of class
GradeBook (lines 8–16) that an instructor can use to
maintain student test scores, and a main function (lines 19–
23) that creates a GradeBook object.
Function main uses this object and its member function to
display a message on the screen welcoming the instructor to
the grade-book program.
24
Classes and Objects …
Function main is always called automatically when
you execute a program.
Most functions do not get called automatically.
You must call member function displayMessageexplicitly to tell it to perform its task.
The access-specifier label public: contains the
keyword public is an access specifier.
Indicates that the function is ―available to the public‖—
that is, it can be called by other functions in the program
(such as main), and by member functions of other classes
(if there are any).
Access specifiers are always followed by a colon (:).27
Classes and Objects …
Each function in a program performs a task and may return a value
when it completes its task.
When you define a function, you must specify a return type to
indicate the type of the value returned by the function when it
completes its task.
Keyword void to the left of the function name displayMessageis the function’s return type.
Indicates that displayMessage will not return any data to its
calling function when it completes its task.
The name of the member function, displayMessage, follows the
return type.
By convention, function names begin with a lowercase first letter and
all subsequent words in the name begin with a capital letter.
28
Classes and Objects …
Empty parentheses indicate that a member function does not
require additional data to perform its task.
The first line of a function definition is commonly called the
function header.
Every function’s body is delimited by left and right braces ({
and }).
The body of a function contains statements that perform the
function’s task.
29
Classes and Objects …
Typically, you cannot call a member function of a class until you
create an object of that class.
First, create an object of class GradeBook called
myGradeBook.
The variable’s type is GradeBook.
The compiler does not automatically know what type GradeBookis—it’s a user-defined type.
Tell the compiler what GradeBook is by including the class
definition.
Each class you create becomes a new type that can be used to create
objects.
Call the member function displayMessage by using variable
myGradeBook followed by the dot operator (.), the function
name display-Message and an empty set of parentheses.30
Classes and Objects …
Fig. 16.3 redefines class GradeBook (lines 9–18) with a
display-Message member function (lines 13–17)
that displays the course name as part of the welcome
message.
The new version of displayMessage requires a parameter
(courseName in line 13) that represents the course name to
output.
A string is actually an object of the C++ Standard Library
class string.
Defined in header file <string> and part of namespace std.
For now, you can think of string variables like variables of
other types such as int.
31
Defining a Member Function with a
Parameter
Library function getline reads a line of text into a
string.
The function call getline( cin, nameOfCourse )reads characters (including the space characters that separate
the words in the input) from the standard input stream object
cin (i.e., the keyboard) until the newline character is
encountered, places the characters in the string variable
nameOfCourse and discards the newline character.
When you press Enter while typing program input, a newline
is inserted in the input stream.
The <string> header file must be included in the program
to use function getline.34
Defining a Member Function with a
Parameter …
top related