C++ Primer, Fifth Edition
would the template parameter of g be if we called g(i = ci)?
Exercise 16.44: Using the same three calls as in the first exercise,
determine the types for T if g’s function parameter is declared as T (not
T&&). What if g’s function parameter is const T&?
Exercise 16.45: Given the following template, explain what happens if we
call g on a literal value such as 42. What if we call g on a variable of type
Click here to view code image
template <typename T> void g(T&& val) { vector<T> v; }
16.2.6. Understanding std::move
The library move function (§ 13.6.1, p. 533) is a good illustration of a template that
uses rvalue references. Fortunately, we can use move without understanding the
template mechanisms that it uses. However, looking at how move works can help
cement our general understanding, and use, of templates.
In § 13.6.2 (p. 534) we noted that although we cannot directly bind an rvalue
reference to an lvalue, we can use move to obtain an rvalue reference bound to an
lvalue. Because move can take arguments of essentially any type, it should not be
surprising that move is a function template.
Is Defined
The standard defines move as follows:
Click here to view code image
// for the use of typename in the return type and the cast see § 16.1.3 (p. 670)
// remove_reference is covered in § 16.2.3 (p. 684)
template <typename T>
typename remove_reference<T>::type&& move(T&& t)
// static_cast covered in § 4.11.3 (p. 163)
This code is short but subtle. First, move’s function parameter, T&&, is an rvalue
reference to a template parameter type. Through reference collapsing, this parameter
can match arguments of any type. In particular, we can pass either an lvalue or an
rvalue to move:
Convert pdf pages into powerpoint slides - 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
convert pdf into ppt online; change pdf to powerpoint on
Convert pdf pages into powerpoint slides - 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 to powerpoint; how to convert pdf to ppt using
C++ Primer, Fifth Edition
Click here to view code image
string s1("hi!"), s2;
s2 = std::move(string("bye!")); // ok: moving from an rvalue
s2 = std::move(s1);  // ok: but after the assigment s1 has indeterminate
In the first assignment, the argument to move is the rvalue result of the string
constructor, string("bye"). As we’ve seen, when we pass an rvalue to an rvalue
reference function parameter, the type deduced from that argument is the referred-to
type (§ 16.2.5, p. 687). Thus, in std::move(string("bye!")):
• The deduced type of T is string.
• Therefore, remove_reference is instantiated with string.
• The type member of remove_reference<string> is string.
• The return type of move is string&&.
• move’s function parameter, t, has type string&&.
Accordingly, this call instantiates move<string>, which is the function
string&& move(string &&t)
The body of this function returns static_cast<string&&>(t). The type of t is
already string&&, so the cast does nothing. Therefore, the result of this call is the
rvalue reference it was given.
Now consider the second assignment, which calls std::move(s1). In this call, the
argument to move is an lvalue. This time:
• The deduced type of T is string& (reference to string, not plain string).
• Therefore, remove_reference is instantiated with string&.
• The type member of remove_reference<string&> is string,
• The return type of move is still string&&.
• move’s function parameter, t, instantiates as string& &&, which collapses to
Thus, this call instantiates move<string&>, which is
string&& move(string &t)
and which is exactly what we’re after—we want to bind an rvalue reference to an
lvalue. The body of this instantiation returns static_cast<string&&>(t). In this
case, the type of t is string&, which the cast converts to string&&.
C# PowerPoint - How to Process PowerPoint
NET PowerPoint control, developers are able to split a PowerPoint into two or It enables you to move out useless PowerPoint document pages simply with
adding pdf to powerpoint slide; convert pdf slides to powerpoint online
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
split one PPT (.pptx) document file into smaller sub library SDK, this VB.NET PowerPoint processing control & profession imaging controls, PDF document, image
image from pdf to ppt; convert pdf to powerpoint
C++ Primer, Fifth Edition
from an Lvalue to an Rvalue Reference Is Permitted
Ordinarily, a static_cast can perform only otherwise legitimate conversions (§
4.11.3, p. 163). However, there is again a special dispensation for rvalue references:
Even though we cannot implicitly convert an lvalue to an rvalue reference, we can
cast an lvalue to an rvalue reference using static_cast.
Binding an rvalue reference to an lvalue gives code that operates on the rvalue
reference permission to clobber the lvalue. There are times, such as in our StrVec
reallocate function in § 13.6.1 (p. 533), when we know it is safe to clobber an
lvalue. By 
us do the cast, the language allows this usage. By 
us to use
a cast, the language tries to prevent us from doing so accidentally.
Finally, although we can write such casts directly, it is much easier to use the library
move function. Moreover, using std::move consistently makes it easy to find the
places in our code that might potentially clobber lvalues.
Exercises Section 16.2.6
Exercise 16.46: Explain this loop from StrVec::reallocate in § 13.5 (p.
Click here to view code image
for (size_t i = 0; i != size(); ++i)
alloc.construct(dest++, std::move(*elem++));
16.2.7. Forwarding
Some functions need to forward one or more of their arguments with their types
to another, forwarded-to, function. In such cases, we need to preserve
everything about the forwarded arguments, including whether or not the argument
type is const, and whether the argument is an lvalue or an rvalue.
As an example, we’ll write a function that takes a callable expression and two
additional arguments. Our function will call the given callable with the other two
arguments in reverse order. The following is a first cut at our flip function:
Click here to view code image
// template that takes a callable and two parameters
// and calls the given callable with the parameters ''flipped''
// flip1 is an incomplete implementation: top-level const and references are lost
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
one of the split PPT document will contain slides/pages 1-4 &ltsummary> ''' Split a document into 2 sub Note: If you want to see more PDF processing functions in
pdf to powerpoint conversion; convert pdf file into ppt
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
and you want to combine these extracted slides into a new of document 1 and some pages of document powerful & profession imaging controls, PDF document, image
how to convert pdf into powerpoint presentation; how to add pdf to powerpoint presentation
C++ Primer, Fifth Edition
template <typename F, typename T1, typename T2>
void flip1(F f, T1 t1, T2 t2)
f(t2, t1);
This template works fine until we want to use it to call a function that has a reference
Click here to view code image
void f(int v1, int &v2) // note v2 is a reference
cout << v1 << " " << ++v2 << endl;
Here f changes the value of the argument bound to v2. However, if we call f
through flip1, the changes made by f do not affect the original argument:
Click here to view code image
f(42, i);        // f changes its argument i
flip1(f, j, 42); // f called through flip1 leaves j unchanged
The problem is that j is passed to the t1 parameter in flip1. That parameter has is
a plain, nonreference type, int, not an int&. That is, the instantiation of this call to
flip1 is
Click here to view code image
void flip1(void(*fcn)(int, int&), int t1, int t2);
The value of j is copied into t1. The reference parameter in f is bound to t1, not to
Defining Function Parameters That Retain Type Information
To pass a reference through our flip function, we need to rewrite our function so that
its parameters preserve the “lvalueness” of its given arguments. Thinking ahead a bit,
we can imagine that we’d also like to preserve the constness of the arguments as
We can preserve all the type information in an argument by defining its
corresponding function parameter as an rvalue reference to a template type
parameter. Using a reference parameter (either lvalue or rvalue) lets us preserve
constness, because the const in a reference type is low-level. Through reference
collapsing (§ 16.2.5, p. 688), if we define the function parameters as T1&& and T2&&,
we can preserve the lvalue/rvalue property of flip’s arguments (§ 16.2.5, p. 687):
Click here to view code image
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
clip art or screenshot to PowerPoint document slide large amount of robust PPT slides/pages editing methods & profession imaging controls, PDF document, image
change pdf to ppt; copying image from pdf to powerpoint
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
guide for PPT document, we divide this page into three parts in VB.NET to create an empty PowerPoint file with or local file and get the exact PPT slides number;
how to convert pdf slides to powerpoint; convert pdf to powerpoint using
C++ Primer, Fifth Edition
template <typename F, typename T1, typename T2>
void flip2(F f, T1 &&t1, T2 &&t2)
f(t2, t1);
As in our earlier call, if we call flip2(f, j, 42), the lvalue j is passed to the
parameter t1. However, in flip2, the type deduced for T1 is int&, which means
that the type of t1 collapses to int&. The reference t1 is bound to j. When flip2
calls f, the reference parameter v2 in f is bound to t1, which in turn is bound to j.
When f increments v2, it is changing the value of j.
A function parameter that is an rvalue reference to a template type
parameter (i.e., T&&) preserves the constness and lvalue/rvalue property of
its corresponding argument.
This version of flip2 solves one half of our problem. Our flip2 function works
fine for functions that take lvalue references but cannot be used to call a function that
has an rvalue reference parameter. For example:
Click here to view code image
void g(int &&i, int& j)
cout << i << " " << j << endl;
If we try to call g through flip2, we will be passing the parameter t2 to g’s rvalue
reference parameter. Even if we pass an rvalue to flip2:
Click here to view code image
flip2(g, i, 42); // error: can't initialize int&& from an lvalue
what is passed to g will be the parameter named t2 inside flip2. A function
parameter, like any other variable, is an lvalue expression (§ 13.6.1, p. 533). As a
result, the call to g in flip2 passes an lvalue to g’s rvalue reference parameter.
to Preserve Type Information in a Call
We can use a new library facility named forward to pass flip2’s parameters in a
way that preserves the types of the original arguments. Like move, forward is
defined in the utility header. Unlike move, forward must be called with an
explicit template argument (§ 16.2.2, p. 682). forward returns an rvalue reference to
VB.NET PowerPoint: Convert & Render PPT into PDF Document
Using this VB.NET PowerPoint to PDF converting demo code below, you can easily convert all slides of source PowerPoint document into a multi-page PDF file.
convert pdf to powerpoint online for; add pdf to powerpoint slide
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
can separate a multi-page PPT document into 2, 4 How to Sort and Reorder PPT Document Pages. provide powerful & profession imaging controls, PDF document, tiff
export pdf to powerpoint; convert pdf to powerpoint online no email
C++ Primer, Fifth Edition
that explicit argument type. That is, the return type of forward<T> is T&&.
Ordinarily, we use forward to pass a function parameter that is defined as an
rvalue reference to a template type parameter. Through reference collapsing on its
return type, forward preserves the lvalue/rvalue nature of its given argument:
Click here to view code image
template <typename Type> intermediary(Type &&arg)
// ...
Here we use Type—which is deduced from arg—as forward’s explicit template
argument type. Because arg is an rvalue reference to a template type parameter,
Type will represent all the type information in the argument passed to arg. If that
argument was an rvalue, then Type is an ordinary (nonreference) type and
forward<Type> will return Type&&. If the argument was an lvalue, then—through
reference collapsing—Type itself is an lvalue reference type. In this case, the return
type is an rvalue reference to an lvalue reference type. Again through reference
collapsing—this time on the return type—forward<Type> will return an lvalue
reference type.
When used with a function parameter that is an rvalue reference to template
type parameter (T&&), forward preserves all the details about an
argument’s type.
Using forward, we’ll rewrite our flip function once more:
Click here to view code image
template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
f(std::forward<T2>(t2), std::forward<T1>(t1));
If we call flip(g, i, 42), i will be passed to g as an int& and 42 will be
passed as an int&&.
As with std::move, it’s a good idea not to provide a using declaration for
std::forward. § 18.2.3 (p. 798) will explain why.
C# PowerPoint: C# Codes to Combine & Split PowerPoint Documents
pages of document 1 and some pages of document &ltsummary> /// Split a document into 2 sub to provide powerful & profession imaging controls, PDF document, tiff
how to change pdf to powerpoint on; convert pdf file to ppt online
VB.NET PowerPoint: Read, Edit and Process PPTX File
How to convert PowerPoint to PDF, render PowerPoint to SVG to read, create, annotate, view, convert and watermark NET PowerPoint reading control SDK into VB.NET
online pdf converter to powerpoint; how to convert pdf to powerpoint on
C++ Primer, Fifth Edition
16.3. Overloading and Templates
Function templates can be overloaded by other templates or by ordinary, nontemplate
functions. As usual, functions with the same name must differ either as to the number
or the type(s) of their parameters.
Exercises Section 16.2.7
Exercise 16.47: Write your own version of the flip function and test it by
calling functions that have lvalue and rvalue reference parameters.
Function matching (§ 6.4, p. 233) is affected by the presence of function templates in
the following ways:
• The candidate functions for a call include any function-template instantiation for
which template argument deduction (§ 16.2, p. 678) succeeds.
• The candidate function templates are always viable, because template argument
deduction will have eliminated any templates that are not viable.
• As usual, the viable functions (template and nontemplate) are ranked by the
conversions, if any, needed to make the call. Of course, the conversions used to
call a function template are quite limited (§ 16.2.1, p. 679).
• Also as usual, if exactly one function provides a better match than any of the
others, that function is selected. However, if there are several functions that
provide an equally good match, then:
– If there is only one nontemplate function in the set of equally good matches,
the nontemplate function is called.
– If there are no nontemplate functions in the set, but there are multiple function
templates, and one of these templates is more specialized than any of the
others, the more specialized function template is called.
– Otherwise, the call is ambiguous.
Correctly defining a set of overloaded function templates requires a good
understanding of the relationship among types and of the restricted
conversions applied to arguments in template functions.
C++ Primer, Fifth Edition
Writing Overloaded Templates
As an example, we’ll build a set of functions that might be useful during debugging.
We’ll name our debugging functions debug_rep, each of which will return a string
representation of a given object. We’ll start by writing the most general version of this
function as a template that takes a reference to a const object:
Click here to view code image
// print any type we don't otherwise handle
template <typename T> string debug_rep(const T &t)
ostringstream ret; // see § 8.3 (p. 321)
ret << t; // uses T's output operator to print a representation of t
return ret.str(); // return a copy of the string to which ret is bound
This function can be used to generate a string corresponding to an object of any
type that has an output operator.
Next, we’ll define a version of debug_rep to print pointers:
Click here to view code image
// print pointers as their pointer value, followed by the object to which the pointer points
// NB: this function will not work properly with char*; see § 16.3 (p. 698)
template <typename T> string debug_rep(T *p)
ostringstream ret;
ret << "pointer: " << p;         // print the pointer's own value
if (p)
ret << " " << debug_rep(*p); // print the value to which p
ret << " null pointer";      // or indicate that the p is null
return ret.str(); // return a copy of the string to which ret is bound
This version generates a string that contains the pointer’s own value and calls
debug_rep to print the object to which that pointer points. Note that this function
can’t be used to print character pointers, because the IO library defines a version of
the << for char* values. That version of << assumes the pointer denotes a null-
terminated character array, and prints the contents of the array, not its address. We’ll
see in § 16.3 (p. 698) how to handle character pointers.
We might use these functions as follows:
Click here to view code image
string s("hi");
C++ Primer, Fifth Edition
cout << debug_rep(s) << endl;
For this call, only the first version of debug_rep is viable. The second version of
debug_rep requires a pointer parameter, and in this call we passed a nonpointer
object. There is no way to instantiate a function template that expects a pointer type
from a nonpointer argument, so argument deduction fails. Because there is only one
viable function, that is the one that is called.
If we call debug_rep with a pointer:
Click here to view code image
cout << debug_rep(&s) << endl;
both functions generate viable instantiations:
• debug_rep(const string* &), which is the instantiation of the first version
of debug_rep with T bound to string*
• debug_rep(string*), which is the instantiation of the second version of
debug_rep with T bound to string
The instantiation of the second version of debug_rep is an exact match for this call.
The instantiation of the first version requires a conversion of the plain pointer to a
pointer to const. Normal function matching says we should prefer the second
template, and indeed that is the one that is run.
Multiple Viable Templates
As another example, consider the following call:
Click here to view code image
const string *sp = &s;
cout << debug_rep(sp) << endl;
Here both templates are viable and both provide an exact match:
• debug_rep(const string* &), the instantiation of the first version of the
template with T bound to const string*
• debug_rep(const string*), the instantiation of the second version of the
template with T bound to const string
In this case, normal function matching can’t distinguish between these two calls. We
might expect this call to be ambiguous. However, due to the special rule for
overloaded function templates, this call resolves to debug_rep(T*), which is the
more specialized template.
The reason for this rule is that without it, there would be no way to call the pointer
version of debug_rep on a pointer to const. The problem is that the template
debug_rep(const T&) can be called on essentially any type, including pointer
types. That template is more general than debug_rep(T*), which can be called only
C++ Primer, Fifth Edition
on pointer types. Without this rule, calls that passed pointers to const would always
be ambiguous.
When there are several overloaded templates that provide an equally good
match for a call, the most specialized version is preferred.
Nontemplate and Template Overloads
For our next example, we’ll define an ordinary nontemplate version of debug_rep to
print strings inside double quotes:
Click here to view code image
// print strings inside double quotes
string debug_rep(const string &s)
return '"' + s + '"';
Now, when we call debug_rep on a string,
Click here to view code image
string s("hi");
cout << debug_rep(s) << endl;
there are two equally good viable functions:
• debug_rep<string>(const string&), the first template with T bound to
• debug_rep(const string&), the ordinary, nontemplate function
In this case, both functions have the same parameter list, so obviously, each function
provides an equally good match for this call. However, the nontemplate version is
selected. For the same reasons that the most specialized of equally good function
templates is preferred, a nontemplate function is preferred over equally good
match(es) to a function template.
When a nontemplate function provides an equally good match for a call as a
function template, the nontemplate version is preferred.
Overloaded Templates and Conversions
Documents you may be interested
Documents you may be interested