C++ Primer, Fifth Edition
string will be destroyed when rhs goes out of scope.
Advice: Updating the Rule of Three
All five copy-control members should be thought of as a unit: Ordinarily, if a
class defines any of these operations, it usually should define them all. As
we’ve seen, some classes 
define the copy constructor, copy-assignment
operator, and destructor to work correctly (§ 13.1.4, p. 504). Such classes
typically have a resource that the copy members must copy. Ordinarily,
copying a resource entails some amount of overhead. Classes that define the
move constructor and move-assignment operator can avoid this overhead in
those circumstances where a copy isn’t necessary.
Move Operations for the 
Classes that define their own copy constructor and copy-assignment operator
generally also benefit by defining the move operations. For example, our Message
and Folder classes (§ 13.4, p. 519) should define move operations. By defining move
operations, the Message class can use the string and set move operations to
avoid the overhead of copying the contents and folders members.
However, in addition to moving the folders member, we must also update each
Folder that points to the original Message. We must remove pointers to the old
Message and add a pointer to the new one.
Both the move constructor and move-assignment operator need to update the
Folder pointers, so we’ll start by defining an operation to do this common work:
Click here to view code image
// move the Folder pointers from m to this Message
void Message::move_Folders(Message *m)
folders = std::move(m->folders); // uses set move assignment
for (auto f : folders) {  // for each Folder
f->remMsg(m);    // remove the old Message from the Folder
f->addMsg(this); // add this Message to that Folder
m->folders.clear();  // ensure that destroying m is harmless
This function begins by moving the folders set. By calling move, we use the set
move assignment rather than its copy assignment. Had we omitted the call to move,
the code would still work, but the copy is unnecessary. The function then iterates
through those Folders, removing the pointer to the original Message and adding a
pointer to the new Message.
Pdf to powerpoint converter online - 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 convert pdf into powerpoint on; how to change pdf to powerpoint format
Pdf to powerpoint converter online - 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
pdf page to powerpoint; convert pdf back to powerpoint
C++ Primer, Fifth Edition
It is worth noting that inserting an element to a set might throw an exception—
adding an element to a container requires memory to be allocated, which means that
a bad_alloc exception might be thrown (§ 12.1.2, p. 460). As a result, unlike our
HasPtr and StrVec move operations, the Message move constructor and move-
assignment operators might throw exceptions. We will not mark them as noexcept (§
13.6.2, p. 535).
The function ends by calling clear on m.folders. After the move, we know that
m.folders is valid but have no idea what its contents are. Because the Message
destructor iterates through folders, we want to be certain that the set is empty.
The Message move constructor calls move to move the contents and default
initializes its folders member:
Click here to view code image
move_Folders(&m); // moves folders and updates the Folder pointers
In the body of the constructor, we call move_Folders to remove the pointers to m
and insert pointers to this Message.
The move-assignment operator does a direct check for self-assignment:
Click here to view code image
Message& Message::operator=(Message &&rhs)
if (this != &rhs) {       // direct check for self-assignment
contents = std::move(rhs.contents); // move assignment
move_Folders(&rhs); // reset the Folders to point to this Message
return *this;
As with any assignment operator, the move-assignment operator must destroy the old
state of the left-hand operand. In this case, destroying the left-hand operand requires
that we remove pointers to this Message from the existing folders, which we do in
the call to remove_from_Folders. Having removed itself from its Folders, we call
move to move the contents from rhs to this object. What remains is to call
move_Messages to update the Folder pointers.
Move Iterators
The reallocate member of StrVec (§ 13.5, p. 530) used a for loop to call
construct to copy the elements from the old memory to the new. As an alternative
Online Convert PowerPoint to PDF file. Best free online export
Online Powerpoint to PDF Converter. Download Free Trial. Convert a PPTX/PPT File to PDF. Just upload your file by clicking on the blue
create powerpoint from pdf; change pdf to ppt
XDoc.Converter for .NET, Support Documents and Images Conversion
Convert PowerPoint to ODP. Convert to Tiff. Convert Word, Excel and PDF to image. Next Steps. Download and try Converter for .NET with online support. See Pricing
and paste pdf to powerpoint; how to convert pdf to ppt
C++ Primer, Fifth Edition
to writing that loop, it would be easier if we could call uninitialized_copy to
construct the newly allocated space. However, uninitialized_copy does what it
says: It copies the elements. There is no analogous library function to “move” objects
into unconstructed memory.
Instead, the new library defines a move iterator adaptor (§ 10.4, p. 401). A move
iterator adapts its given iterator by changing the behavior of the iterator’s dereference
operator. Ordinarily, an iterator dereference operator returns an lvalue reference to
the element. Unlike other iterators, the dereference operator of a move iterator yields
an rvalue reference.
We transform an ordinary iterator to a move iterator by calling the library
make_move_iterator function. This function takes an iterator and returns a move
All of the original iterator’s other operations work as usual. Because these iterators
support normal iterator operations, we can pass a pair of move iterators to an
algorithm. In particular, we can pass move iterators to uninitialized_copy:
Click here to view code image
void StrVec::reallocate()
// allocate space for twice as many elements as the current size
auto newcapacity = size() ? 2 * size() : 1;
auto first = alloc.allocate(newcapacity);
// move the elements
free();             // free the old space
elements = first;   // update the pointers
first_free = last;
cap = elements + newcapacity;
uninitialized_copy calls construct on each element in the input sequence to
“copy” that element into the destination. That algorithm uses the iterator dereference
operator to fetch elements from the input sequence. Because we passed move
iterators, the dereference operator yields an rvalue reference, which means
construct will use the move constructor to construct the elements.
It is worth noting that standard library makes no guarantees about which algorithms
can be used with move iterators and which cannot. Because moving an object can
obliterate the source, you should pass move iterators to algorithms only when you are
that the algorithm does not access an element after it has assigned to that
element or passed that element to a user-defined function.
C#: How to Use SDK to Convert Document and Image Using XDoc.
You may use our converter SDK to easily convert PDF, Word, Excel, PowerPoint, Tiff, and Dicom files to raster images like Jpeg, Png, Bmp and Gif.
how to convert pdf to powerpoint slides; pdf to ppt converter online
RasterEdge XDoc.PowerPoint for .NET - SDK for PowerPoint Document
Add image to specified position on PowerPoint page. Next Steps. Download Free Trial Download and try PDF for .NET with online support. See Pricing
converting pdf to powerpoint online; export pdf to powerpoint
C++ Primer, Fifth Edition
Advice: Don’t Be Too Quick to Move
Because a moved-from object has indeterminate state, calling std::move on
an object is a dangerous operation. When we call move, we must be
absolutely certain that there can be no other users of the moved-from object.
Judiciously used inside class code, move can offer significant performance
benefits. Casually used in ordinary user code (as opposed to class
implementation code), moving an object is more likely to lead to mysterious
and hard-to-find bugs than to any improvement in the performance of the
Best Practices
Outside of class implementation code such as move constructors or
move-assignment operators, use std::move only when you 
are certain
that you need to do a move and that the move is guaranteed to be safe.
Exercises Section 13.6.2
Exercise 13.49: Add a move constructor and move-assignment operator to
your StrVec, String, and Message classes.
Exercise 13.50: Put print statements in the move operations in your
String class and rerun the program from exercise 13.48 in § 13.6.1 (p.
534) that used a vector<String> to see when the copies are avoided.
Exercise 13.51: Although unique_ptrs cannot be copied, in § 12.1.5 (p.
471) we wrote a clone function that returned a unique_ptr by value.
Explain why that function is legal and how it works.
Exercise 13.52: Explain in detail what happens in the assignments of the
HasPtr objects on page 541. In particular, describe step by step what
happens to values of hp, hp2, and of the rhs parameter in the HasPtr
assignment operator.
Exercise 13.53: As a matter of low-level efficiency, the HasPtr assignment
operator is not ideal. Explain why. Implement a copy-assignment and move-
assignment operator for HasPtr and compare the operations executed in
your new move-assignment operator versus the copy-and-swap version.
Exercise 13.54: What would happen if we defined a HasPtr move-
assignment operator but did not change the copy-and-swap operator? Write
code to test your answer.
VB.NET PDF - Convert PDF Online with VB.NET HTML5 PDF Viewer
All Formats. XDoc.HTML5 Viewer. XDoc.Windows Viewer. XDoc.Converter. View & Process. Adobe PDF. XDoc.PDF. Scanning. XDoc.Word. XDoc.Excel. XDoc.PowerPoint. Barcoding
adding pdf to powerpoint slide; changing pdf to powerpoint
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
All Formats. XDoc.HTML5 Viewer. XDoc.Windows Viewer. XDoc.Converter. View & Process. Adobe PDF. XDoc.PDF. Scanning. XDoc.Word. XDoc.Excel. XDoc.PowerPoint. Barcoding
pdf to powerpoint converter; how to convert pdf slides to powerpoint
C++ Primer, Fifth Edition
13.6.3. Rvalue References and Member Functions
Member functions other than constructors and assignment can benefit from providing
both copy and move versions. Such move-enabled members typically use the same
parameter pattern as the copy/move constructor and the assignment operators—one
version takes an lvalue reference to const, and the second takes an rvalue reference
to nonconst.
For example, the library containers that define push_back provide two versions:
one that has an rvalue reference parameter and the other a const lvalue reference.
Assuming X is the element type, these containers define:
Click here to view code image
void push_back(const X&); // copy: binds to any kind of X
void push_back(X&&);      // move: binds only to modifiable rvalues of type
We can pass any object that can be converted to type X to the first version of
push_back. This version copies data from its parameter. We can pass only an rvalue
that is not const to the second version. This version is an exact match (and a better
match) for nonconst rvalues and will be run when we pass a modifiable rvalue (§
13.6.2, p. 539). This version is free to steal resources from its parameter.
Ordinarily, there is no need to define versions of the operation that take a const
X&& or a (plain) X&. Usually, we pass an rvalue reference when we want to “steal”
from the argument. In order to do so, the argument must not be const. Similarly,
copying from an object should not change the object being copied. As a result, there
is usually no need to define a version that take a (plain) X& parameter.
Overloaded functions that distinguish between moving and copying a
parameter typically have one version that takes a const T& and one that
takes a T&&.
As a more concrete example, we’ll give our StrVec class a second version of
Click here to view code image
class StrVec {
void push_back(const std::string&);  // copy the element
void push_back(std::string&&);       // move the element
C# HTML5 PDF Viewer SDK to convert and export PDF document to
All Formats. XDoc.HTML5 Viewer. XDoc.Windows Viewer. XDoc.Converter. View & Process. Adobe PDF. XDoc.PDF. Scanning. XDoc.Word. XDoc.Excel. XDoc.PowerPoint. Barcoding
chart from pdf to powerpoint; convert pdf slides to powerpoint online
DocImage SDK for .NET: Web Document Image Viewer Online Demo
Try Online Demo Now. Please click Browse to upload a file to display in web viewer. Suppported files are Word, Excel, PowerPoint, PDF, Tiff, Dicom and main
changing pdf to powerpoint file; convert pdf file to powerpoint presentation
C++ Primer, Fifth Edition
// other members as before
// unchanged from the original version in § 13.5 (p. 527)
void StrVec::push_back(const string& s)
chk_n_alloc(); // ensure that there is room for another element
// construct a copy of s in the element to which first_free points
alloc.construct(first_free++, s);
void StrVec::push_back(string &&s)
chk_n_alloc(); // reallocates the StrVec if necessary
alloc.construct(first_free++, std::move(s));
These members are nearly identical. The difference is that the rvalue reference version
of push_back calls move to pass its parameter to construct. As we’ve seen, the
construct function uses the type of its second and subsequent arguments to
determine which constructor to use. Because move returns an rvalue reference, the
type of the argument to construct is string&&. Therefore, the string move
constructor will be used to construct a new last element.
When we call push_back the type of the argument determines whether the new
element is copied or moved into the container:
Click here to view code image
StrVec vec;  // empty StrVec
string s = "some string or another";
vec.push_back(s);      // calls push_back(const string&)
vec.push_back("done"); // calls push_back(string&&)
These calls differ as to whether the argument is an lvalue (s) or an rvalue (the
temporary string created from "done"). The calls are resolved accordingly.
Rvalue and Lvalue Reference Member Functions
Ordinarily, we can call a member function on an object, regardless of whether that
object is an lvalue or an rvalue. For example:
Click here to view code image
string s1 = "a value", s2 = "another";
auto n = (s1 + s2).find('a');
Here, we called the find member (§ 9.5.3, p. 364) on the string rvalue that results
from adding two strings. Sometimes such usage can be surprising:
s1 + s2 = "wow!";
Here we assign to the rvalue result of concatentating these strings.
C++ Primer, Fifth Edition
Prior to the new standard, there was no way to prevent such usage. In order to
maintain backward compatability, the library classes continue to allow assignment to
rvalues, However, we might want to prevent such usage in our own classes. In this
case, we’d like to force the left-hand operand (i.e., the object to which this points)
to be an lvalue.
We indicate the lvalue/rvalue property of this in the same way that we define
const member functions (§ 7.1.2, p. 258); we place a reference qualifier after the
parameter list:
Click here to view code image
class Foo {
Foo &operator=(const Foo&) &; // may assign only to modifiable
// other members of Foo
Foo &Foo::operator=(const Foo &rhs) &
// do whatever is needed to assign rhs to this object
return *this;
The reference qualifier can be either & or &&, indicating that this may point to an
rvalue or lvalue, respectively. Like the const qualifier, a reference qualifier may
appear only on a (nonstatic) member function and must appear in both the
declaration and definition of the function.
We may run a function qualified by & only on an lvalue and may run a function
qualified by && only on an rvalue:
Click here to view code image
Foo &retFoo();  // returns a reference; a call to retFoo is an lvalue
Foo retVal();   // returns by value; a call to retVal is an rvalue
Foo i, j;       // i and j are lvalues
i = j;          // ok: i is an lvalue
retFoo() = j;   // ok: retFoo(returns an lvalue
retVal() = j;   // error: retVal() returns an rvalue
i = retVal();   // ok: we can pass an rvalue as the right-hand operand to
A function can be both const and reference qualified. In such cases, the reference
qualifier must follow the const qualifier:
Click here to view code image
class Foo {
C++ Primer, Fifth Edition
Foo someMem() & const;    // error: const qualifier must come first
Foo anotherMem() const &; // ok: const qualifier comes first
Overloading and Reference Functions
Just as we can overload a member function based on whether it is const (§ 7.3.2, p.
276), we can also overload a function based on its reference qualifier. Moreover, we
may overload a function by its reference qualifier and by whether it is a const
member. As an example, we’ll give Foo a vector member and a function named
sorted that returns a copy of the Foo object in which the vector is sorted:
Click here to view code image
class Foo {
Foo sorted() &&;         // may run on modifiable rvalues
Foo sorted() const &;    // may run on any kind of Foo
// other members of Foo
vector<int> data;
// this object is an rvalue, so we can sort in place
Foo Foo::sorted() &&
sort(data.begin(), data.end());
return *this;
// this object is either const or it is an lvalue; either way we can't sort in place
Foo Foo::sorted() const & {
Foo ret(*this);                         // make a copy
sort(ret.data.begin(), ret.data.end()); // sort the copy
return ret;                             // return the copy
When we run sorted on an rvalue, it is safe to sort the data member directly. The
object is an rvalue, which means it has no other users, so we can change the object
itself. When we run sorted on a const rvalue or on an lvalue, we can’t change this
object, so we copy data before sorting it.
Overload resolution uses the lvalue/rvalue property of the object that calls sorted
to determine which version is used:
Click here to view code image
retVal().sorted(); // retVal(is an rvalue, calls Foo::sorted() &&
retFoo().sorted(); // retFoo(is an lvalue, calls Foo::sorted() const &
C++ Primer, Fifth Edition
When we define const memeber functions, we can define two versions that differ
only in that one is const qualified and the other is not. There is no similar default for
reference qualified functions. When we define two or more members that have the
same name and the same parameter list, we must provide a reference qualifier on all
or none of those functions:
Click here to view code image
class Foo {
Foo sorted() &&;
Foo sorted() const; // error: must have reference qualifier
// Comp is type alias for the function type (see § 6.7 (p. 249))
// that can be used to compare int values
using Comp = bool(const int&, const int&);
Foo sorted(Comp*);        // ok: different parameter list
Foo sorted(Comp*) const;  // ok: neither version is reference qualified
Here the declaration of the const version of sorted that has no parameters is an
error. There is a second version of sorted that has no parameters and that function
has a reference qualifier, so the const version of that function must have a reference
qualifier as well. On the other hand, the versions of sorted that take a pointer to a
comparison operation are fine, because neither function has a qualifier.
If a member function has a reference qualifier, all the versions of that
member with the same parameter list must have reference qualifiers.
Exercises Section 13.6.3
Exercise 13.55: Add an rvalue reference version of push_back to your
Exercise 13.56: What would happen if we defined sorted as:
Click here to view code image
Foo Foo::sorted() const & {
Foo ret(*this);
return ret.sorted();
Exercise 13.57: What if we defined sorted as:
Click here to view code image
C++ Primer, Fifth Edition
Foo Foo::sorted() const & { return Foo(*this).sorted(); }
Exercise 13.58: Write versions of class Foo with print statements in their
sorted functions to test your answers to the previous two exercises.
Chapter Summary
Each class controls what happens when we copy, move, assign, or destroy objects of
its type. Special member functions—the copy constructor, move constructor, copy-
assignment operator, move-assignment operator, and destructor—define these
operations. The move constructor and move-assignment operator take a (usually
nonconst) rvalue reference; the copy versions take a (usually const) ordinary lvalue
If a class declares none of these operations, the compiler will define them
automatically. If not defined as deleted, these operations memberwise initialize, move,
assign, or destroy the object: Taking each nonstatic data member in turn, the
synthesized operation does whatever is appropriate to the member’s type to move,
copy, assign, or destroy that member.
Classes that allocate memory or other resources almost always require that the class
define the copy-control members to manage the allocated resource. If a class needs a
destructor, then it almost surely needs to define the move and copy constructors and
the move- and copy-assignment operators as well.
Defined Terms
copy and swap Technique for writing assignment operators by copying the
right-hand operand followed by a call to swap to exchange the copy with the left-
hand operand.
copy-assignment operator Version of the assignment operator that takes an
object of the same type as its type. Ordinarily, the copy-assignment operator has
a parameter that is a reference to const and returns a reference to its object.
The compiler synthesizes the copy-assignment operator if the class does not
explicitly provide one.
copy constructor Constructor that initializes a new object as a copy of another
object of the same type. The copy constructor is applied implicitly to pass objects
to or from a function by value. If we do not provide the copy constructor, the
compiler synthesizes one for us.
copy control Special members that control what happens when objects of class
type are copied, moved, assigned, and destroyed. The compiler synthesizes
Documents you may be interested
Documents you may be interested