C++ Primer, Fifth Edition
6.2.3. const Parameters and Arguments
When we use parameters that are const, it is important to remember the discussion
of top-level const from § 2.4.3 (p. 63). As we saw in that section, a top-level const
is one that applies to the object itself:
Click here to view code image
const int ci = 42;     // we cannot change ci; const is top-level
int i = ci;            // ok: when we copy ci, its top-level const is
ignored
int * const p = &i;    // const is top-level; we can't assign to p
*p = 0;                // ok: changes through p are allowed; i is now 0
Just as in any other initialization, when we copy an argument to initialize a parameter,
top-level consts are ignored. As a result, top-level const on parameters are
ignored. We can pass either a const or a nonconst object to a parameter that has
a top-level const:
Click here to view code image
void fcn(const int i) { /* fcn can read but not write to i */ }
We can call fcn passing it either a const int or a plain int. The fact that top-level
consts are ignored on a parameter has one possibly surprising implication:
Click here to view code image
void fcn(const int i) { /* fcn can read but not write to i */ }
void fcn(int i) { /* . . . */ } // error: redefines fcn(int)
In C++, we can define several different functions that have the same name. However,
we can do so only if their parameter lists are sufficiently different. Because top-level
consts are ignored, we can pass exactly the same types to either version of fcn.
The second version of fcn is an error. Despite appearances, its parameter list doesn’t
differ from the list in the first version of fcn.
Pointer or Reference Parameters and 
const
Because parameters are initialized in the same way that variables are initialized, it can
be helpful to remember the general initialization rules. We can initialize an object with
a low-level const from a nonconst object but not vice versa, and a plain reference
must be initialized from an object of the same type.
Click here to view code image
www.it-ebooks.info
How to convert pdf to powerpoint on - 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
how to change pdf to powerpoint on; picture from pdf to powerpoint
How to convert pdf to powerpoint on - 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
convert pdf into powerpoint; pdf to ppt
C++ Primer, Fifth Edition
int i = 42;
const int *cp = &i; // ok: but cp can't change i (§ 2.4.2 (p. 62))
const int &r = i;   // ok: but r can't change i (§ 2.4.1 (p. 61))
const int &r2 = 42; // ok: (§ 2.4.1 (p. 61))
int *p = cp;  // error: types of p and cp don't match (§ 2.4.2 (p. 62))
int &r3 = r;  // error: types of r3 and r don't match (§ 2.4.1 (p. 61))
int &r4 = 42; // error: can't initialize a plain reference from a literal (§ 2.3.1 (p.
50))
Exactly the same initialization rules apply to parameter passing:
Click here to view code image
int i = 0;
const int ci = i;
string::size_type ctr = 0;
reset(&i);   // calls the version of reset that has an int* parameter
reset(&ci);  // error: can't initialize an int* from a pointer to a const int object
reset(i);    // calls the version of reset that has an int& parameter
reset(ci);   // error: can't bind a plain reference to the const object ci
reset(42);   // error: can't bind a plain reference to a literal
reset(ctr);  // error: types don't match; ctr has an unsigned type
// okfind_char's first parameter is a reference to const
find_char("Hello World!", 'o', ctr);
We can call the reference version of reset (§ 6.2.2, p. 210) only on int objects. We
cannot pass a literal, an expression that evaluates to an int, an object that requires
conversion, or a const int object. Similarly, we may pass only an int* to the
pointer version of reset (§ 6.2.1, p. 209). On the other hand, we can pass a string
literal as the first argument to find_char (§ 6.2.2, p. 211). That function’s reference
parameter is a reference to const, and we can initialize references to const from
literals.
Use Reference to 
const
When Possible
It is a somewhat common mistake to define parameters that a function does not
change as (plain) references. Doing so gives the function’s caller the misleading
impression that the function might change its argument’s value. Moreover, using a
reference instead of a reference to const unduly limits the type of arguments that
can be used with the function. As we’ve just seen, we cannot pass a const object, or
a literal, or an object that requires conversion to a plain reference parameter.
The effect of this mistake can be surprisingly pervasive. As an example, consider our
find_char function from § 6.2.2 (p. 211). That function (correctly) made its string
parameter a reference to const. Had we defined that parameter as a plain string&:
www.it-ebooks.info
Online Convert PowerPoint to PDF file. Best free online export
Download Free Trial. Convert a PPTX/PPT File to PDF. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
convert pdf to editable ppt online; how to change pdf file to powerpoint
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
pdf conversion to powerpoint; convert pdf to powerpoint slides
C++ Primer, Fifth Edition
Click here to view code image
// bad design: the first parameter should be a const string&
string::size_type find_char(string &s, char c,
string::size_type &occurs);
we could call find_char only on a string object. A call such as
Click here to view code image
find_char("Hello World", 'o', ctr);
would fail at compile time.
More subtly, we could not use this version of find_char from other functions that
(correctly) define their parameters as references to const. For example, we might
want to use find_char inside a function that determines whether a string
represents a sentence:
Click here to view code image
bool is_sentence(const string &s)
{
// if there's a single period at the end of s, then s is a sentence
string::size_type ctr = 0;
return find_char(s, '.', ctr) == s.size() - 1 && ctr ==
1;
}
If find_char took a plain string&, then this call to find_char would be a
compile-time error. The problem is that s is a reference to a const string, but
find_char was (incorrectly) defined to take a plain reference.
It might be tempting to try to fix this problem by changing the type of the
parameter in is_sentence. But that fix only propagates the error—callers of
is_sentence could pass only nonconst strings.
The right way to fix this problem is to fix the parameter in find_char. If it’s not
possible to change find_char, then define a local string copy of s inside
is_sentence and pass that string to find_char.
6.2.4. Array Parameters
Arrays have two special properties that affect how we define and use functions that
operate on arrays: We cannot copy an array (§ 3.5.1, p. 114), and when we use an
array it is (usually) converted to a pointer (§ 3.5.3, p. 117). Because we cannot copy
an array, we cannot pass an array by value. Because arrays are converted to pointers,
when we pass an array to a function, we are actually passing a pointer to the array’s
first element.
Even though we cannot pass an array by value, we can write a parameter that looks
www.it-ebooks.info
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Convert PDF to Image; Convert Word to PDF; Convert Excel to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF;
how to convert pdf into powerpoint presentation; pdf picture to powerpoint
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Convert PDF to HTML. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF to HTML. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
how to convert pdf to powerpoint on; export pdf into powerpoint
C++ Primer, Fifth Edition
like an array:
Exercises Section 6.2.3
Exercise 6.16: The following function, although legal, is less useful than it
might be. Identify and correct the limitation on this function:
Click here to view code image
bool is_empty(string& s) { return s.empty(); }
Exercise 6.17: Write a function to determine whether a string contains
any capital letters. Write a function to change a string to all lowercase. Do
the parameters you used in these functions have the same type? If so, why?
If not, why not?
Exercise 6.18: Write declarations for each of the following functions. When
you write these declarations, use the name of the function to indicate what
the function does.
(a) A function named compare that returns a bool and has two parameters
that are references to a class named matrix.
(b) A function named change_val that returns a vector<int> iterator
and takes two parameters: One is an int and the other is an iterator for a
vector<int>.
Exercise 6.19: Given the following declarations, determine which calls are
legal and which are illegal. For those that are illegal, explain why.
Click here to view code image
double calc(double);
int count(const string &, char);
int 
sum(vector<int>::iterator, 
vector<int>::iterator,
int);
vector<int> vec(10);
(a) calc(23.4, 55.1);
(b) count("abcda", 'a');
(c) calc(66);
(d) sum(vec.begin(), vec.end(), 3.8);
Exercise 6.20: When should reference parameters be references to const?
What happens if we make a parameter a plain reference when it could be a
reference to const?
Click here to view code image
// despite appearances, these three declarations of print are equivalent
www.it-ebooks.info
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. C# Demo: Convert PowerPoint to PDF Document. Add references: RasterEdge.Imaging.Basic.dll.
convert pdf to ppt online without email; conversion of pdf into ppt
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Convert PDF to HTML. |. C#.NET PDF SDK - Convert PDF to HTML in C#.NET. How to Use C# .NET XDoc.PDF SDK to Convert PDF to HTML Webpage in C# .NET Program.
convert pdf into ppt online; convert pdf into powerpoint online
C++ Primer, Fifth Edition
// each function has a single parameter of type const int*
void print(const int*);
void print(const int[]);   // shows the intent that the function takes an
array
void print(const int[10]); // dimension for documentation purposes (at
best)
Regardless of appearances, these declarations are equivalent: Each declares a function
with a single parameter of type const int*. When the compiler checks a call to
print, it checks only that the argument has type const int*:
Click here to view code image
int i = 0, j[2] = {0, 1};
print(&i); // ok: &i is int*
print(j);  // ok: j is converted to an int* that points to j[0]
If we pass an array to print, that argument is automatically converted to a pointer
to the first element in the array; the size of the array is irrelevant.
Warning
As with any code that uses arrays, functions that take array parameters must
ensure that all uses of the array stay within the array bounds.
Because arrays are passed as pointers, functions ordinarily don’t know the size of
the array they are given. They must rely on additional information provided by the
caller. There are three common techniques used to manage pointer parameters.
Using a Marker to Specify the Extent of an Array
The first approach to managing array arguments requires the array itself to contain an
end marker. C-style character strings (§ 3.5.4, p. 122) are an example of this
approach. C-style strings are stored in character arrays in which the last character of
the string is followed by a null character. Functions that deal with C-style strings stop
processing the array when they see a null character:
Click here to view code image
void print(const char *cp)
{
if (cp)          // if cp is not a null pointer
while (*cp)  // so long as the character it points to is not a null
character
cout << *cp++; // print the character and advance the pointer
}
www.it-ebooks.info
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
change pdf to powerpoint online; image from pdf to powerpoint
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
VB.NET PDF - Convert PDF to TIFF Using VB in VB.NET. Free VB.NET Guide to Render and Convert PDF Document to TIFF in Visual Basic Class.
chart from pdf to powerpoint; change pdf to ppt
C++ Primer, Fifth Edition
This convention works well for data where there is an obvious end-marker value (like
the null character) that does not appear in ordinary data. It works less well with data,
such as ints, where every value in the range is a legitimate value.
Using the Standard Library Conventions
A second technique used to manage array arguments is to pass pointers to the first
and one past the last element in the array. This approach is inspired by techniques
used in the standard library. We’ll learn more about this style of programming in Part
II. Using this approach, we’ll print the elements in an array as follows:
Click here to view code image
void print(const int *beg, const int *end)
{
// print every element starting at beg up to but not including end
while (beg != end)
cout << *beg++ << endl; // print the current element
// and advance the pointer
}
The while uses the dereference and postfix increment operators (§ 4.5, p. 148) to
print the current element and advance beg one element at a time through the array.
The loop stops when beg is equal to end.
To call this function, we pass two pointers—one to the first element we want to
print and one just past the last element:
Click here to view code image
int j[2] = {0, 1};
// j is converted to a pointer to the first element in j
// the second argument is a pointer to one past the end of j
print(begin(j), end(j)); // begin and end functions, see § 3.5.3 (p. 118)
This function is safe, as long as the caller correctly calculates the pointers. Here we let
the library begin and end functions (§ 3.5.3, p. 118) provide those pointers.
Explicitly Passing a Size Parameter
A third approach for array arguments, which is common in C programs and older C++
programs, is to define a second parameter that indicates the size of the array. Using
this approach, we’ll rewrite print as follows:
Click here to view code image
// const int ia[] is equivalent to const int* ia
// size is passed explicitly and used to control access to elements of ia
www.it-ebooks.info
C++ Primer, Fifth Edition
void print(const int ia[], size_t size)
{
for (size_t i = 0; i != size; ++i) {
cout << ia[i] << endl;
}
}
This version uses the size parameter to determine how many elements there are to
print. When we call print, we must pass this additional parameter:
Click here to view code image
int j[] = { 0, 1 };  // int array of size 2
print(j, end(j) - begin(j));
The function executes safely as long as the size passed is no greater than the actual
size of the array.
Array Parameters and 
const
Note that all three versions of our print function defined their array parameters as
pointers to const. The discussion in § 6.2.3 (p. 213) applies equally to pointers as to
references. When a function does not need write access to the array elements, the
array parameter should be a pointer to const (§ 2.4.2, p. 62). A parameter should be
a plain pointer to a nonconst type only if the function needs to change element
values.
Array Reference Parameters
Just as we can define a variable that is a reference to an array (§ 3.5.1, p. 114), we
can define a parameter that is a reference to an array. As usual, the reference
parameter is bound to the corresponding argument, which in this case is an array:
Click here to view code image
// ok: parameter is a reference to an array; the dimension is part of the type
void print(int (&arr)[10])
{
for (auto elem : arr)
cout << elem << endl;
}
Note
The parentheses around &arr are necessary (§ 3.5.1, p. 114):
Click here to view code image
f(int &arr[10])   // error: declares arr as an array of references
www.it-ebooks.info
C++ Primer, Fifth Edition
f(int (&arr)[10]) // ok: arr is a reference to an array of ten ints
Because the size of an array is part of its type, it is safe to rely on the dimension in
the body of the function. However, the fact that the size is part of the type limits the
usefulness of this version of print. We may call this function only for an array of
exactly ten ints:
Click here to view code image
int i = 0, j[2] = {0, 1};
int k[10] = {0,1,2,3,4,5,6,7,8,9};
print(&i);   // error: argument is not an array of ten ints
print(j);    // error: argument is not an array of ten ints
print(k);    // ok: argument is an array of ten ints
We’ll see in § 16.1.1 (p. 654) how we might write this function in a way that would
allow us to pass a reference parameter to an array of any size.
Passing a Multidimensional Array
Recall that there are no multidimensional arrays in C++ (§ 3.6, p. 125). Instead, what
appears to be a multidimensional array is an array of arrays.
As with any array, a multidimensional array is passed as a pointer to its first
element (§ 3.6, p. 128). Because we are dealing with an array of arrays, that element
is an array, so the pointer is a pointer to an array. The size of the second (and any
subsequent) dimension is part of the element type and must be specified:
Click here to view code image
// matrix points to the first element in an array whose elements are arrays of ten ints
void print(int (*matrix)[10], int rowSize) { /* . . . */ }
declares matrix as a pointer to an array of ten ints.
Note
Again, the parentheses around *matrix are necessary:
Click here to view code image
int *matrix[10];   // array of ten pointers
int (*matrix)[10]; // pointer to an array of ten ints
We can also define our function using array syntax. As usual, the compiler ignores
the first dimension, so it is best not to include it:
www.it-ebooks.info
C++ Primer, Fifth Edition
Click here to view code image
// equivalent definition
void print(int matrix[][10], int rowSize) { /* . . . */ }
declares matrix to be what looks like a two-dimensional array. In fact, the parameter
is a pointer to an array of ten ints.
6.2.5. main: Handling Command-Line Options
It turns out that main is a good example of how C++ programs pass arrays to
functions. Up to now, we have defined main with an empty parameter list:
int main() { ... }
However, we sometimes need to pass arguments to main. The most common use of
arguments to main is to let the user specify a set of options to guide the operation of
the program. For example, assuming our main program is in an executable file named
prog, we might pass options to the program as follows:
Exercises Section 6.2.4
Exercise 6.21: Write a function that takes an int and a pointer to an int
and returns the larger of the int value or the value to which the pointer
points. What type should you use for the pointer?
Exercise 6.22: Write a function to swap two int pointers.
Exercise 6.23: Write your own versions of each of the print functions
presented in this section. Call each of these functions to print i and j
defined as follows:
int i = 0, j[2] = {0, 1};
Exercise 6.24: Explain the behavior of the following function. If there are
problems in the code, explain what they are and how you might fix them.
Click here to view code image
void print(const int ia[10])
{
for (size_t i = 0; i != 10; ++i)
cout << ia[i] << endl;
}
prog -d -o ofile data0
Such command-line options are passed to main in two (optional) parameters:
Click here to view code image
www.it-ebooks.info
C++ Primer, Fifth Edition
int main(int argc, char *argv[]) { ... }
The second parameter, argv, is an array of pointers to C-style character strings. The
first parameter, argc, passes the number of strings in that array. Because the second
parameter is an array, we might alternatively define main as
Click here to view code image
int main(int argc, char **argv) { ... }
indicating that argv points to a char*.
When arguments are passed to main, the first element in argv points either to the
name of the program or to the empty string. Subsequent elements pass the
arguments provided on the command line. The element just past the last pointer is
guaranteed to be 0.
Given the previous command line, argc would be 5, and argv would hold the
following C-style character strings:
Click here to view code image
argv[0] = "prog";   // or argv[0] might point to an empty string
argv[1] = "-d";
argv[2] = "-o";
argv[3] = "ofile";
argv[4] = "data0";
argv[5] = 0;
Warning
When you use the arguments in argv, remember that the optional
arguments begin in argv[1]; argv[0] contains the program’s name, not
user input.
Exercises Section 6.2.5
Exercise 6.25: Write a main function that takes two arguments.
Concatenate the supplied arguments and print the resulting string.
Exercise 6.26: Write a program that accepts the options presented in this
section. Print the values of the arguments passed to main.
6.2.6. Functions with Varying Parameters
Sometimes we do not know in advance how many arguments we need to pass to a
www.it-ebooks.info
Documents you may be interested
Documents you may be interested