C++ Primer, Fifth Edition
void f2(void){ /* ... */ } // explicit void parameter list
A parameter list typically consists of a comma-separated list of parameters, each of
which looks like a declaration with a single declarator. Even when the types of two
parameters are the same, the type must be repeated:
Click here to view code image
int f3(int v1, v2) { /* ... */ }     // error
int f4(int v1, int v2) { /* ... */ } // ok
No two parameters can have the same name. Moreover, local variables at the
outermost scope of the function may not use the same name as any parameter.
Parameter names are optional. However, there is no way to use an unnamed
parameter. Therefore, parameters ordinarily have names. Occasionally a function has a
parameter that is not used. Such parameters are often left unnamed, to indicate that
they aren’t used. Leaving a parameter unnamed doesn’t change the number of
arguments that a call must supply. A call must supply an argument for every
parameter, even if that parameter isn’t used.
Function Return Type
Most types can be used as the return type of a function. In particular, the return type
can be void, which means that the function does not return a value. However, the
return type may not be an array type (§ 3.5, p. 113) or a function type. However, a
function may return a pointer to an array or a function. We’ll see how to define
functions that return pointers (or references) to arrays in § 6.3.3 (p. 228) and how to
return pointers to functions in § 6.7 (p. 247).
6.1.1. Local Objects
In C++, names have scope (§ 2.2.4, p. 48), and objects have lifetimes. It is
important to understand both of these concepts.
• The scope of a name is 
the part of the program’s text
in which that name is
• The lifetime of an object is 
the time during the program’s execution
that the
object exists.
As we’ve seen, the body of a function is a statement block. As usual, the block
forms a new scope in which we can define variables. Parameters and variables defined
inside a function body are referred to as local variables. They are “local” to that
function and hide declarations of the same name made in an outer scope.
Convert pdf to powerpoint slide - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
converting pdf to powerpoint slides; and paste pdf to powerpoint
Convert pdf to powerpoint slide - VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in vb.net, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
and paste pdf into powerpoint; drag and drop pdf into powerpoint
C++ Primer, Fifth Edition
Exercises Section 6.1
Exercise 6.1: What is the difference between a parameter and an
Exercise 6.2: Indicate which of the following functions are in error and why.
Suggest how you might correct the problems.
(a) int f() {
string s;
// ...
return s;
(b) f2(int i) { /* ... */ }
(c) int calc(int v1, int v1) /* ... */ }
(d) double square(double x) return x * x;
Exercise 6.3: Write and test your own version of fact.
Exercise 6.4: Write a function that interacts with the user, asking for a
number and generating the factorial of that number. Call this function from
Exercise 6.5: Write a function to return the absolute value of its argument.
Objects defined outside any function exist throughout the program’s execution. Such
objects are created when the program starts and are not destroyed until the program
ends. The lifetime of a local variable depends on how it is defined.
Automatic Objects
The objects that correspond to ordinary local variables are created when the function’s
control path passes through the variable’s definition. They are destroyed when control
passes through the end of the block in which the variable is defined. Objects that exist
only while a block is executing are known as automatic objects. After execution
exits a block, the values of the automatic objects created in that block are undefined.
Parameters are automatic objects. Storage for the parameters is allocated when the
function begins. Parameters are defined in the scope of the function body. Hence they
are destroyed when the function terminates.
Automatic objects corresponding to the function’s parameters are initialized by the
arguments passed to the function. Automatic objects corresponding to local variables
are initialized if their definition contains an initializer. Otherwise, they are default
initialized (§ 2.2.1, p. 43), which means that uninitialized local variables of built-in type
have undefined values.
VB.NET PowerPoint: Read, Edit and Process PPTX File
to convert PowerPoint to PDF, render PowerPoint PowerPoint to TIFF and convert PowerPoint to raster desired watermark on source PowerPoint slide at specified
pdf to ppt converter online for large; image from pdf to powerpoint
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
Suitable for Processing PowerPoint Slide(s) in both Web & SDK, this VB.NET PowerPoint processing control add & profession imaging controls, PDF document, image
how to convert pdf into powerpoint presentation; changing pdf to powerpoint
C++ Primer, Fifth Edition
It can be useful to have a local variable whose lifetime continues across calls to the
function. We obtain such objects by defining a local variable as static. Each local
static object is initialized before the 
time execution passes through the object’s
definition. Local statics are not destroyed when a function ends; they are destroyed
when the program terminates.
As a trivial example, here is a function that counts how many times it is called:
Click here to view code image
size_t count_calls()
static size_t ctr = 0;  // value will persist across calls
return ++ctr;
int main()
for (size_t i = 0; i != 10; ++i)
cout << count_calls() << endl;
return 0;
This program will print the numbers from 1 through 10 inclusive.
Before control flows through the definition of ctr for the first time, ctr is created
and given an initial value of 0. Each call increments ctr and returns its new value.
Whenever count_calls is executed, the variable ctr already exists and has
whatever value was in that variable the last time the function exited. Thus, on the
second invocation, the value of ctr is 1, on the third it is 2, and so on.
If a local static has no explicit initializer, it is value initialized (§ 3.3.1, p. 98),
meaning that local statics of built-in type are initialized to zero.
Exercises Section 6.1.1
Exercise 6.6: Explain the differences between a parameter, a local variable,
and a local static variable. Give an example of a function in which each
might be useful.
Exercise 6.7: Write a function that returns 0 when it is first called and then
generates numbers in sequence each time it is called again.
6.1.2. Function Declarations
Like any other name, the name of a function must be declared before we can use it.
As with variables (§ 2.2.2, p. 45), a function may be defined only once but may be
declared multiple times. With one exception that we’ll cover in § 15.3 (p. 603), we can
C# PowerPoint - How to Process PowerPoint
Visual C# Codes to Process PowerPoint Slide; PowerPoint C#.NET Processor. C#.NET PowerPoint: Process and Edit PowerPoint Slide(s).
convert pdf to powerpoint slides; how to add pdf to powerpoint slide
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
VB.NET PPT PDF-417 barcode scanning SDK to detect PDF-417 barcode image from PowerPoint slide. VB.NET APIs to detect and decode
pdf to powerpoint converter online; pdf page to powerpoint
C++ Primer, Fifth Edition
declare a function that is not defined so long as we never use that function.
A function declaration is just like a function definition except that a declaration has
no function body. In a declaration, a semicolon replaces the function body.
Because a function declaration has no body, there is no need for parameter names.
Hence, parameter names are often omitted in a declaration. Although parameter
names are not required, they can be used to help users of the function understand
what the function does:
Click here to view code image
// parameter names chosen to indicate that the iterators denote a range of values to print
void print(vector<int>::const_iterator beg,
vector<int>::const_iterator end);
These three elements—the return type, function name, and parameter types—describe
the function’s interface. They specify all the information we need to call the function.
Function declarations are also known as the function prototype.
Function Declarations Go in Header Files
Recall that variables are declared in header files (§ 2.6.3, p. 76) and defined in source
files. For the same reasons, functions should be declared in header files and defined in
source files.
It may be tempting—and would be legal—to put a function declaration directly in
each source file that uses the function. However, doing so is tedious and error-prone.
When we use header files for our function declarations, we can ensure that all the
declarations for a given function agree. Moreover, if the interface to the function
changes, only one declaration has to be changed.
The source file that defines a function should include the header that contains that
function’s declaration. That way the compiler will verify that the definition and
declaration are consistent.
Best Practices
The header that 
a function should be included in the source file that
that function.
Exercises Section 6.1.2
Exercise 6.8: Write a header file named Chapter6.h that contains
declarations for the functions you wrote for the exercises in § 6.1 (p. 205).
VB.NET PowerPoint: Convert & Render PPT into PDF Document
How to Convert PowerPoint Slide to PDF Using VB.NET Code in .NET. What VB.NET APIs can I use to convert PowerPoint slide to PDF document file?
how to change pdf to powerpoint slides; pdf to powerpoint conversion
VB.NET PowerPoint: Edit PowerPoint Slide; Insert, Add or Delete
To view more VB.NET PowerPoint slide processing functions read VB.NET PPT (.pptx) slide processing guide page & profession imaging controls, PDF document, image
how to convert pdf to powerpoint; pdf to ppt
C++ Primer, Fifth Edition
6.1.3. Separate Compilation
As our programs get more complicated, we’ll want to store the various parts of the
program in separate files. For example, we might store the functions we wrote for the
exercises in § 6.1 (p. 205) in one file and store code that uses these functions in
other source files. To allow programs to be written in logical parts, C++ supports what
is commonly known as 
separate compilation
. Separate compilation lets us split our
programs into several files, each of which can be compiled independently.
Compiling and Linking Multiple Source Files
As an example, assume that the definition of our fact function is in a file named
fact.cc and its declaration is in a header file named Chapter6.h. Our fact.cc
file, like any file that uses these functions, will include the Chapter6.h header. We’ll
store a main function that calls fact in a second file named factMain.cc. To
produce an 
executable file
, we must tell the compiler where to find all of the code we
use. We might compile these files as follows:
Click here to view code image
$ CC factMain.cc fact.cc   # generates factMain.exe or a.out
$ CC factMain.cc fact.cc -o main # generates main or
Here CC is the name of our compiler, $ is our system prompt, and # begins a
command-line comment. We can now run the executable file, which will run our main
If we have changed only one of our source files, we’d like to recompile only the file
that actually changed. Most compilers provide a way to separately compile each file.
This process usually yields a file with the .obj (Windows) or .o (UNIX) file extension,
indicating that the file contains 
object code
The compiler lets us 
object files together to form an executable. On the system
we use, we would separately compile our program as follows:
Click here to view code image
$ CC -c factMain.cc     # generates factMain.o
$ CC -c fact.cc         # generates fact.o
$ CC factMain.o fact.o  # generates factMain.exe or a.out
$ CC factMain.o fact.o -o main # generates main or main.exe
You’ll need to check with your compiler’s user’s guide to understand how to compile
and execute programs made up of multiple source files.
Exercises Section 6.1.3
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
PowerPoint image insertion, please read this VB.NET PowerPoint slide processing tutorial to provide powerful & profession imaging controls, PDF document, image
convert pdf to powerpoint online for; converting pdf to powerpoint
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
is used to note or comment PowerPoint (.pptx) slide as a kind of compensation for limitations (other documents are compatible, including PDF, TIFF, MS Word and
how to change pdf file to powerpoint; convert pdf slides to powerpoint online
C++ Primer, Fifth Edition
Exercise 6.9: Write your own versions of the fact.cc and factMain.cc
files. These files should include your Chapter6.h from the exercises in the
previous section. Use these files to understand how your compiler supports
separate compilation.
6.2. Argument Passing
As we’ve seen, each time we call a function, its parameters are created and initialized
by the arguments passed in the call.
Parameter initialization works the same way as variable initialization.
As with any other variable, the type of a parameter determines the interaction
between the parameter and its argument. If the parameter is a reference (§ 2.3.1, p.
50), then the parameter is bound to its argument. Otherwise, the argument’s value is
When a parameter is a reference, we say that its corresponding argument is
“passed by reference” or that the function is “called by reference.” As with any
other reference, a reference parameter is an alias for the object to which it is bound;
that is, the parameter is an alias for its corresponding argument.
When the argument value is copied, the parameter and argument are independent
objects. We say such arguments are “passed by value” or alternatively that the
function is “called by value.”
6.2.1. Passing Arguments by Value
When we initialize a nonreference type variable, the value of the initializer is copied.
Changes made to the variable have no effect on the initializer:
Click here to view code image
int n = 0;             // ordinary variable of type int
int i = n;             // i is a copy of the value in n
i = 42;                // value in i is changed; n is unchanged
Passing an argument by value works exactly the same way; nothing the function does
VB.NET PowerPoint: How to Convert PowerPoint Document to TIFF in
PowerPoint is often used by programmers in many applications formats, such as JPEG, GIF and PDF, by using is designed by our programmers to convert PPT document
pdf to ppt converter online; how to convert pdf file to powerpoint presentation
VB.NET PowerPoint: Render PowerPoint to REImage for Further
Doc Conversion Library can be used to convert PPT document or image pages, including but not limited to PowerPoint document slide/page, PDF file page and
how to convert pdf to powerpoint; pdf page to powerpoint
C++ Primer, Fifth Edition
to the parameter can affect the argument. For example, inside fact (§ 6.1, p. 202)
the parameter val is decremented:
Click here to view code image
ret *= val--;  // decrements the value of val
Although fact changes the value of val, that change has no effect on the argument
passed to fact. Calling fact(i) does not change the value of i.
Pointer Parameters
Pointers (§ 2.3.2, p. 52) behave like any other nonreference type. When we copy a
pointer, the value of the pointer is copied. After the copy, the two pointers are
distinct. However, a pointer also gives us indirect access to the object to which that
pointer points. We can change the value of that object by assigning through the
pointer (§ 2.3.2, p. 55):
Click here to view code image
int n = 0, i = 42;
int *p = &n, *q = &i; // p points to n; q points to i
*p = 42;              // value in n is changed; p is unchanged
p = q;                // p now points to i; values in i and n are
The same behavior applies to pointer parameters:
Click here to view code image
// function that takes a pointer and sets the pointed-to value to zero
void reset(int *ip)
*ip = 0;  // changes the value of the object to which ip points
ip = 0;   // changes only the local copy of ip; the argument is unchanged
After a call to reset, the object to which the argument points will be 0, but the
pointer argument itself is unchanged:
Click here to view code image
int i = 42;
reset(&i);                    // changes i but not the address of i
cout << "i = " << i << endl;  // prints i = 0
Best Practices
Programmers accustomed to programming in C often use pointer parameters
C++ Primer, Fifth Edition
to access objects outside a function. In C++, programmers generally use
reference parameters instead.
Exercises Section 6.2.1
Exercise 6.10: Using pointers, write a function to swap the values of two
ints. Test the function by calling it and printing the swapped values.
6.2.2. Passing Arguments by Reference
Recall that operations on a reference are actually operations on the object to which
the reference refers (§ 2.3.1, p. 50):
Click here to view code image
int n = 0, i = 42;
int &r = n;           // r is bound to n (i.e., r is another name for n)
r = 42;               // n is now 42
r = i;                // n now has the same value as i
i = r;                // i has the same value as n
Reference parameters exploit this behavior. They are often used to allow a function to
change the value of one or more of its arguments.
As one example, we can rewrite our reset program from the previous section to
take a reference instead of a pointer:
Click here to view code image
// function that takes a reference to an int and sets the given object to zero
void reset(int &i)  // i is just another name for the object passed to reset
i = 0;  // changes the value of the object to which i refers
As with any other reference, a reference parameter is bound directly to the object
from which it is initialized. When we call this version of reset, i will be bound to
whatever int object we pass. As with any reference, changes made to i are made to
the object to which i refers. In this case, that object is the argument to reset.
When we call this version of reset, we pass an object directly; there is no need to
pass its address:
Click here to view code image
C++ Primer, Fifth Edition
int j = 42;
reset(j);  // j is passed by reference; the value in j is changed
cout << "j = " << j  << endl;  // prints j = 0
In this call, the parameter i is just another name for j. Any use of i inside reset is
a use of j.
Using References to Avoid Copies
It can be inefficient to copy objects of large class types or large containers. Moreover,
some class types (including the IO types) cannot be copied. Functions must use
reference parameters to operate on objects of a type that cannot be copied.
As an example, we’ll write a function to compare the length of two strings.
Because strings can be long, we’d like to avoid copying them, so we’ll make our
parameters references. Because comparing two strings does not involve changing
the strings, we’ll make the parameters references to const (§ 2.4.1, p. 61):
Click here to view code image
// compare the length of two strings
bool isShorter(const string &s1, const string &s2)
return s1.size() < s2.size();
As we’ll see in § 6.2.3 (p. 213), functions should use references to const for
reference parameters they do not need to change.
Best Practices
Reference parameters that are not changed inside a function should be
references to const.
Using Reference Parameters to Return Additional Information
A function can return only a single value. However, sometimes a function has more
than one value to return. Reference parameters let us effectively return multiple
results. As an example, we’ll define a function named find_char that will return the
position of the first occurrence of a given character in a string. We’d also like the
function to return a count of how many times that character occurs.
How can we define a function that returns a position and an occurrence count? We
could define a new type that contains the position and the count. An easier solution is
to pass an additional reference argument to hold the occurrence count:
C++ Primer, Fifth Edition
Click here to view code image
// returns the index of the first occurrence of c in s
// the reference parameter occurs counts how often c occurs
string::size_type find_char(const string &s, char c,
string::size_type &occurs)
auto ret = s.size();   // position of the first occurrence, if any
occurs = 0;            // set the occurrence count parameter
for (decltype(ret) i = 0; i != s.size(); ++i) {
if (s[i] == c) {
if (ret == s.size())
ret = i;   // remember the first occurrence of c
++occurs;      // increment the occurrence count
return ret;            // count is returned implicitly in occurs
When we call find_char, we have to pass three arguments: a string in which to
look, the character to look for, and a size_type (§ 3.2.2, p. 88) object to hold the
occurrence count. Assuming s is a string, and ctr is a size_type object, we can
call find_char as follows:
auto index = find_char(s, 'o', ctr);
After the call, the value of ctr will be the number of times o occurs, and index will
refer to the first occurrence if there is one. Otherwise, index will be equal to
s.size() and ctr will be zero.
Exercises Section 6.2.2
Exercise 6.11: Write and test your own version of reset that takes a
Exercise 6.12: Rewrite the program from exercise 6.10 in § 6.2.1 (p. 210)
to use references instead of pointers to swap the value of two ints. Which
version do you think would be easier to use and why?
Exercise 6.13: Assuming T is the name of a type, explain the difference
between a function declared as void f(T) and void f(T&).
Exercise 6.14: Give an example of when a parameter should be a reference
type. Give an example of when a parameter should not be a reference.
Exercise 6.15: Explain the rationale for the type of each of find_char’s
parameters In particular, why is s a reference to const but occurs is a
plain reference? Why are these parameters references, but the char
parameter c is not? What would happen if we made s a plain reference?
What if we made occurs a reference to const?
Documents you may be interested
Documents you may be interested