C++ Primer, Fifth Edition
vector<long> vi = {0,1,2,3,4,5,6,7,8,9};
list<const char*> w = {"now", "is", "the", "time"};
// instantiates the Blob<int> class
// and the Blob<int> constructor that has two int* parameters
Blob<int> a1(begin(ia), end(ia));
// instantiates the Blob<int> constructor that has
// two vector<long>::iterator parameters
Blob<int> a2(vi.begin(), vi.end());
// instantiates the Blob<string> class and the Blob<string>
// constructor that has two (list<const char*>::iterator parameters
Blob<string> a3(w.begin(), w.end());
When we define a1, we explicitly specify that the compiler should instantiate a version
of Blob with the template parameter bound to int. The type parameter for the
constructor’s own parameters will be deduced from the type of begin(ia) and
end(ia). That type is int*. Thus, the definition of a1 instantiates:
Blob<int>::Blob(int*, int*);
The definition of a2 uses the already instantiated Blob<int> class, and instantiates
the constructor with It replaced by vector<short>::iterator. The definition of
a3 (explicitly) instantiates the Blob with its template parameter bound to string
and (implicitly) instantiates the member template constructor of that class with its
parameter bound to list<const char*>.
Exercises Section 16.1.4
Exercise 16.21: Write your own version of DebugDelete.
Exercise 16.22: Revise your TextQuery programs from § 12.3 (p. 484) so
that the shared_ptr members use a DebugDelete as their deleter (§
12.1.4, p. 468).
Exercise 16.23: Predict when the call operator will be executed in your
main query program. If your expectations and what happens differ, be sure
you understand why.
Exercise 16.24: Add a constructor that takes two iterators to your Blob
16.1.5. Controlling Instantiations
The fact that instantiations are generated when a template is used (§ 16.1.1, p. 656)
means that the same instantiation may appear in multiple object files. When two or
more separately compiled source files use the same template with the same template
arguments, there is an instantiation of that template in each of those files.
Convert pdf slides to powerpoint - 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
add pdf to powerpoint slide; converting pdf to ppt
Convert pdf slides to powerpoint - 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
export pdf to powerpoint; how to convert pdf to powerpoint
C++ Primer, Fifth Edition
In large systems, the overhead of instantiating the same template in multiple files
can become significant. Under the new standard, we can avoid this overhead through
an explicit instantiation. An explicit instantiation has the form
Click here to view code image
extern template declaration; // instantiation declaration
template declaration;        // instantiation definition
is a class or function declaration in which all the template
parameters are replaced by the template arguments. For example,
Click here to view code image
// instantion declaration and definition
extern template class Blob<string>;             // declaration
template int compare(const int&, const int&);   // definition
When the compiler sees an extern template declaration, it will not generate code for
that instantiation in that file. Declaring an instantiation as extern is a promise that
there will be a nonextern use of that instantiation elsewhere in the program. There
may be several extern declarations for a given instantiation but there must be
exactly one definition for that instantiation.
Because the compiler automatically instantiates a template when we use it, the
extern declaration must appear before any code that uses that instantiation:
Click here to view code image
// Application.cc
// these template types must be instantiated elsewhere in the program
extern template class Blob<string>;
extern template int compare(const int&, const int&);
Blob<string> sa1, sa2; // instantiation will appear elsewhere
// Blob<int> and its initializer_list constructor instantiated in this file
Blob<int> a1 = {0,1,2,3,4,5,6,7,8,9};
Blob<int> a2(a1);  // copy constructor instantiated in this file
int i = compare(a1[0], a2[0]); // instantiation will appear elsewhere
The file Application.o will contain instantiations for Blob<int>, along with the
initializer_list and copy constructors for that class. The compare<int>
function and Blob<string> class will not be instantiated in that file. There must be
definitions of these templates in some other file in the program:
Click here to view code image
// templateBuild.cc
// instantiation file must provide a (nonextern) definition for every
// type and function that other files declare as extern
C# PowerPoint - How to Process PowerPoint
slides sorting library can help you a lot. Extract Slides from PowerPoint in C#.NET. Use C# sample code to extract single or several
convert pdf to powerpoint; convert pdf back to powerpoint
VB.NET PowerPoint: Read, Edit and Process PPTX File
split PowerPoint file, change the order of PPTX sildes and extract one or more slides from PowerPoint How to convert PowerPoint to PDF, render PowerPoint to
conversion of pdf into ppt; convert pdf to powerpoint online for
C++ Primer, Fifth Edition
template int compare(const int&, const int&);
template class Blob<string>; // instantiates all members of the class
When the compiler sees an instantiation definition (as opposed to a declaration), it
generates code. Thus, the file templateBuild.o will contain the definitions for
compare instantiated with int and for the Blob<string> class. When we build the
application, we must link templateBuild.o with the Application.o files.
There must be an explicit instantiation definition somewhere in the program
for every instantiation declaration.
Instantiation Definitions Instantiate All Members
An instantiation definition for a class template instantiates 
the members of that
template including inline member functions. When the compiler sees an instantiation
definition it cannot know which member functions the program uses. Hence, unlike the
way it handles ordinary class template instantiations, the compiler instantiates 
members of that class. Even if we do not use a member, that member will be
instantiated. Consequently, we can use explicit instantiation only for types that can be
used with all the members of that template.
An instantiation definition can be used only for types that can be used with
every member function of a class template.
16.1.6. Efficiency and Flexibility
The library smart pointer types (§ 12.1, p. 450) offer a good illustration of design
choices faced by designers of templates.
The obvious difference between shared_ptr and unique_ptr is the strategy
they use in managing the pointer they hold—one class gives us shared ownership; the
other owns the pointer that it holds. This difference is essential to what these classes
These classes also differ in how they let users override their default deleter. We can
easily override the deleter of a shared_ptr by passing a callable object when we
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
add image to slide, extract slides and merge library SDK, this VB.NET PowerPoint processing control powerful & profession imaging controls, PDF document, image
pdf to powerpoint; convert pdf pages into powerpoint slides
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 powerful & profession imaging controls, PDF document, image
how to change pdf to powerpoint slides; convert pdf to powerpoint slide
C++ Primer, Fifth Edition
create or reset the pointer. In contrast, the type of the deleter is part of the type of
a unique_ptr object. Users must supply that type as an explicit template argument
when they define a unique_ptr. As a result, it is more complicated for users of
unique_ptr to provide their own deleter.
Exercises Section 16.1.5
Exercise 16.25: Explain the meaning of these declarations:
Click here to view code image
extern template class vector<string>;
template class vector<Sales_data>;
Exercise 16.26: Assuming NoDefault is a class that does not have a
default constructor, can we explicitly instantiate vector<NoDefault>? If
not, why not?
Exercise 16.27: For each labeled statement explain what, if any,
instantiations happen. If a template is instantiated, explain why; if not,
explain why not.
Click here to view code image
template <typename T> class Stack { };
void f1(Stack<char>);                   // (a)
class Exercise {
Stack<double> &rsd;                 // (b)
Stack<int>    si;                   // (c)
int main() {
Stack<char> *sc;                    // (d)
f1(*sc);                            // (e)
int iObj = sizeof(Stack< string >); // (f)
The difference in how the deleter is handled is incidental to the functionality of
these classes. However, as we’ll see, this difference in implementation strategy may
have important performance impacts.
Binding the Deleter at Run Time
Although we don’t know how the library types are implemented, we can infer that
shared_ptr must access its deleter indirectly. That is the deleter must be stored as
a pointer or as a class (such as function (§ 14.8.3, p. 577)) that encapsulates a
We can be certain that shared_ptr does not hold the deleter as a direct member,
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
Besides, users also can get the precise PowerPoint slides count as soon as the PowerPoint document has been loaded by using the page number getting method.
adding pdf to powerpoint slide; how to convert pdf into powerpoint slides
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
want to combine these extracted slides into a please read this VB.NET PowerPoint slide processing powerful & profession imaging controls, PDF document, image
how to convert pdf into powerpoint presentation; convert pdf to editable powerpoint online
C++ Primer, Fifth Edition
because the type of the deleter isn’t known until run time. Indeed, we can change the
type of the deleter in a given shared_ptr during that shared_ptr’s lifetime. We
can construct a shared_ptr using a deleter of one type, and subsequently use
reset to give that same shared_ptr a different type of deleter. In general, we
cannot have a member whose type changes at run time. Hence, the deleter must be
stored indirectly.
To think about how the deleter must work, let’s assume that shared_ptr stores
the pointer it manages in a member named p, and that the deleter is accessed
through a member named del. The shared_ptr destructor must include a
statement such as
Click here to view code image
// value of del known only at run time; call through a pointer
del ? del(p) : delete p; // del(p) requires run-time jump to del's location
Because the deleter is stored indirectly, the call del(p) requires a run-time jump to
the location stored in del to execute the code to which del points.
Binding the Deleter at Compile Time
Now, let’s think about how unique_ptr might work. In this class, the type of the
deleter is part of the type of the unique_ptr. That is, unique_ptr has two
template parameters, one that represents the pointer that the unique_ptr manages
and the other that represents the type of the deleter. Because the type of the deleter
is part of the type of a unique_ptr, the type of the deleter member is known at
compile time. The deleter can be stored directly in each unique_ptr object.
The unique_ptr destructor operates similarly to its shared_ptr counterpart in
that it calls a user-supplied deleter or executes delete on its stored pointer:
Click here to view code image
// del bound at compile time; direct call to the deleter is instantiated
del(p);   // no run-time overhead
The type of del is either the default deleter type or a user-supplied type. It doesn’t
matter; either way the code that will be executed is known at compile time. Indeed, if
the deleter is something like our DebugDelete class (§ 16.1.4, p. 672) this call might
even be inlined at compile time.
By binding the deleter at compile time, unique_ptr avoids the run-time cost of an
indirect call to its deleter. By binding the deleter at run time, shared_ptr makes it
easier for users to override the deleter.
Exercises Section 16.1.6
Exercise 16.28: Write your own versions of shared_ptr and
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
of the split PPT document will contain slides/pages 1-4 code in VB.NET to finish PowerPoint document splitting If you want to see more PDF processing functions
how to convert pdf into powerpoint; convert pdf into ppt
VB.NET PowerPoint: Complete PowerPoint Document Conversion in VB.
It contains PowerPoint documentation features and all PPT slides. Control to render and convert target PowerPoint or document formats, such as PDF, BMP, TIFF
pdf to ppt converter online for large; pdf to ppt converter online
C++ Primer, Fifth Edition
Exercise 16.29: Revise your Blob class to use your version of
shared_ptr rather than the library version.
Exercise 16.30: Rerun some of your programs to verify your shared_ptr
and revised Blob classes. (Note: Implementing the weak_ptr type is
beyond the scope of this Primer, so you will not be able to use the BlobPtr
class with your revised Blob.)
Exercise 16.31: Explain how the compiler might inline the call to the deleter
if we used DebugDelete with unique_ptr.
16.2. Template Argument Deduction
We’ve seen that, by default, the compiler uses the arguments in a call to determine
the template parameters for a function template. The process of determining the
template arguments from the function arguments is known as template argument
deduction. During template argument deduction, the compiler uses types of the
arguments in the call to find the template arguments that generate a version of the
function that best matches the given call.
16.2.1. Conversions and Template Type Parameters
As with a nontemplate function, the arguments we pass in a call to a function
template are used to initialize that function’s parameters. Function parameters whose
type uses a template type parameter have special initialization rules. Only a very
limited number of conversions are automatically applied to such arguments. Rather
than converting the arguments, the compiler generates a new instantiation.
As usual, top-level consts (§ 2.4.3, p. 63) in either the parameter or the argument
are ignored. The only other conversions performed in a call to a function template are
• const conversions: A function parameter that is a reference (or pointer) to a
const can be passed a reference (or pointer) to a nonconst object (§ 4.11.2,
p. 162).
• Array- or function-to-pointer conversions: If the function parameter is not a
reference type, then the normal pointer conversion will be applied to arguments
of array or function type. An array argument will be converted to a pointer to its
first element. Similarly, a function argument will be converted to a pointer to the
function’s type (§ 4.11.2, p. 161).
Other conversions, such as the arithmetic conversions (§ 4.11.1, p. 159), derived-to-
base (§ 15.2.2, p. 597), and user-defined conversions (§ 7.5.4, p. 294, and § 14.9, p.
579), are not performed.
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.
converting pdf to ppt online; how to convert pdf slides to powerpoint presentation
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
insert or delete any certain PowerPoint slide without methods to reorder current PPT slides in both powerful & profession imaging controls, PDF document, tiff
convert pdf pages to powerpoint slides; how to change pdf to ppt on
C++ Primer, Fifth Edition
As examples, consider calls to the functions fobj and fref. The fobj function
copies its parameters, whereas fref’s parameters are references:
Click here to view code image
template <typename T> T fobj(T, T); // arguments are copied
template <typename T> T fref(const T&, const T&); // references
string s1("a value");
const string s2("another value");
fobj(s1, s2); // calls fobj(string, string); const is ignored
fref(s1, s2); // calls fref(const string&, const string&)
// uses premissible conversion to const on s1
int a[10], b[42];
fobj(a, b); // calls f(int*, int*)
fref(a, b); // error: array types don't match
In the first pair of calls, we pass a string and a const string. Even though these
types do not match exactly, both calls are legal. In the call to fobj, the arguments
are copied, so whether the original object is const doesn’t matter. In the call to
fref, the parameter type is a reference to const. Conversion to const for a
reference parameter is a permitted conversion, so this call is legal.
In the next pair of calls, we pass array arguments in which the arrays are different
sizes and hence have different types. In the call to fobj, the fact that the array types
differ doesn’t matter. Both arrays are converted to pointers. The template parameter
type in fobj is int*. The call to fref, however, is illegal. When the parameter is a
reference, the arrays are not converted to pointers (§ 6.2.4, p. 217). The types of a
and b don’t match, so the call is in error.
const conversions and array or function to pointer are the only automatic
conversions for arguments to parameters with template types.
Function Parameters That Use the Same Template Parameter Type
A template type parameter can be used as the type of more than one function
parameter. Because there are limited conversions, the arguments to such parameters
must have essentially the same type. If the deduced types do not match, then the call
is an error. For example, our compare function (§ 16.1.1, p. 652) takes two const
T& parameters. Its arguments must have essentially the same type:
Click here to view code image
long lng;
C++ Primer, Fifth Edition
compare(lng, 1024); // error: cannot instantiate compare(long, int)
This call is in error because the arguments to compare don’t have the same type.
The template argument deduced from the first argument is long; the one for the
second is int. These types don’t match, so template argument deduction fails.
If we want to allow normal conversions on the arguments, we can define the
function with two type parameters:
Click here to view code image
// argument types can differ but must be compatible
template <typename A, typename B>
int flexibleCompare(const A& v1, const B& v2)
if (v1 < v2) return -1;
if (v2 < v1) return 1;
return 0;
Now the user may supply arguments of different types:
Click here to view code image
long lng;
flexibleCompare(lng, 1024); // ok: calls flexibleCompare(long, int)
Of course, a < operator must exist that can compare values of those types.
Normal Conversions Apply for Ordinary Arguments
A function template can have parameters that are defined using ordinary types—that
is, types that do not involve a template type parameter. Such arguments have no
special processing; they are converted as usual to the corresponding type of the
parameter (§ 6.1, p. 203). For example, consider the following template:
Click here to view code image
template <typename T> ostream &print(ostream &os, const T
return os << obj;
The first function parameter has a known type, ostream&. The second parameter,
obj, has a template parameter type. Because the type of os is fixed, normal
conversions are applied to arguments passed to os when print is called:
Click here to view code image
print(cout, 42); // instantiates print(ostream&, int)
ofstream f("output");
print(f, 10);    // uses print(ostream&, int); converts f to ostream&
C++ Primer, Fifth Edition
In the first call, the type of the first argument exactly matches the type of the first
parameter. This call will cause a version of print that takes an ostream& and an
int to be instantiated. In the second call, the first argument is an ofstream and
there is a conversion from ofstream to ostream& (§ 8.2.1, p. 317). Because the
type of this parameter does not depend on a template parameter, the compiler will
implicitly convert f to ostream&.
Normal conversions are applied to arguments whose type is not a template
Exercises Section 16.2.1
Exercise 16.32: What happens during template argument deduction?
Exercise 16.33: Name two type conversions allowed on function arguments
involved in template argument deduction.
Exercise 16.34: Given only the following code, explain whether each of
these calls is legal. If so, what is the type of T? If not, why not?
Click here to view code image
template <class T> int compare(const T&, const T&);
(a) compare("hi", "world");
(b) compare("bye", "dad");
Exercise 16.35: Which, if any, of the following calls are errors? If the call is
legal, what is the type of T? If the call is not legal, what is the problem?
Click here to view code image
template <typename T> T calc(T, int);
template <typename T> T fcn(T, T);
double d;    float f;    char c;
(a) calc(c, 'c');
(b) calc(d, f);
(c) fcn(c, 'c');
(d) fcn(d, f);
Exercise 16.36: What happens in the following calls:
Click here to view code image
template <typename T> f1(T, T);
template <typename T1, typename T2) f2(T1, T2);
C++ Primer, Fifth Edition
int i = 0, j = 42, *p1 = &i, *p2 = &j;
const int *cp1 = &i, *cp2 = &j;
(a) f1(p1, p2);
(b) f2(p1, p2);
(c) f1(cp1, cp2);
(d) f2(cp1, cp2);
(e) f1(p1, cp1);
(f) f2(p1, cp1);
16.2.2. Function-Template Explicit Arguments
In some situations, it is not possible for the compiler to deduce the types of the
template arguments. In others, we want to allow the user to control the template
instantiation. Both cases arise most often when a function return type differs from any
of those used in the parameter list.
Specifying an Explicit Template Argument
As an example in which we want to let the user specify which type to use, we’ll define
a function template named sum that takes arguments of two different types. We’d like
to let the user specify the type of the result. That way the user can choose whatever
precision is appropriate.
We can let the user control the type of the return by defining a third template
parameter to represent the return type:
Click here to view code image
// T1 cannot be deduced: it doesn't appear in the function parameter list
template <typename T1, typename T2, typename T3>
T1 sum(T2, T3);
In this case, there is no argument whose type can be used to deduce the type of T1.
The caller must provide an explicit template argument for this parameter on each
call to sum.
We supply an explicit template argument to a call the same way that we define an
instance of a class template. Explicit template arguments are specified inside angle
brackets after the function name and before the argument list:
Click here to view code image
// T1 is explicitly specified; T2 and T3 are inferred from the argument types
Documents you may be interested
Documents you may be interested