C++ Primer, Fifth Edition
// the compiler won't automatically apply this conversion
explicit operator int() const { return val; }
// other members as before
As with an explicit constructor (§ 7.5.4, p. 296), the compiler won’t (generally) use
an explicit conversion operator for implicit conversions:
Click here to view code image
SmallInt si = 3;  // ok: the SmallInt constructor is not explicit
si + 3; // error: implicit is conversion required, but operator int is explicit
static_cast<int>(si) + 3; // ok: explicitly request the conversion
If the conversion operator is explicit, we can still do the conversion. However, with
one exception, we must do so explicitly through a cast.
The exception is that the compiler will apply an explicit conversion to an
expression used as a condition. That is, an explicit conversion will be used
implicitly to convert an expression used as
• The condition of an if, while, or do statement
• The condition expression in a for statement header
• An operand to the logical 
(||), or 
(&&) operators
• The condition expression in a conditional (?:) operator
Conversion to 
In earlier versions of the library, the IO types defined a conversion to void*. They
did so to avoid the kinds of problems illustrated above. Under the new standard, the
IO library instead defines an explicit conversion to bool.
Whenever we use a stream object in a condition, we use the operator bool that
is defined for the IO types. For example,
while (std::cin >> value)
The condition in the while executes the input operator, which reads into value and
returns cin. To evaluate the condition, cin is implicitly converted by the istream
operator bool conversion function. That function returns true if the condition
state of cin is good (§ 8.1.2, p. 312), and false otherwise.
Best Practices
Conversion to bool is usually intended for use in conditions. As a result,
operator bool ordinarily should be defined as explicit.
Converting pdf to 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
how to convert pdf into powerpoint; add pdf to powerpoint
Converting pdf to 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
add pdf to powerpoint presentation; convert pdf to powerpoint slide
C++ Primer, Fifth Edition
Exercises Section 14.9.1
Exercise 14.45: Write conversion operators to convert a Sales_data to
string and to double. What values do you think these operators should
Exercise 14.46: Explain whether defining these Sales_data conversion
operators is a good idea and whether they should be explicit.
Exercise 14.47: Explain the difference between these two conversion
struct Integral {
operator const int();
operator int() const;
Exercise 14.48: Determine whether the class you used in exercise 7.40 from
§ 7.5.1 (p. 291) should have a conversion to bool. If so, explain why, and
explain whether the operator should be explicit. If not, explain why not.
Exercise 14.49: Regardless of whether it is a good idea to do so, define a
conversion to bool for the class from the previous exercise.
14.9.2. Avoiding Ambiguous Conversions
If a class has one or more conversions, it is important to ensure that there is only one
way to convert from the class type to the target type. If there is more than one way
to perform a conversion, it will be hard to write unambiguous code.
There are two ways that multiple conversion paths can occur. The first happens
when two classes provide mutual conversions. For example, mutual conversions exist
when a class A defines a converting constructor that takes an object of class B and B
itself defines a conversion operator to type A.
The second way to generate multiple conversion paths is to define multiple
conversions from or to types that are themselves related by conversions. The most
obvious instance is the built-in arithmetic types. A given class ordinarily ought to
define at most one conversion to or from an arithmetic type.
Ordinarily, it is a bad idea to define classes with mutual conversions or to
define conversions to or from two arithmetic types.
Argument Matching and Mutual Conversions
VB.NET PowerPoint: Complete PowerPoint Document Conversion in VB.
Control to render and convert target PowerPoint document to or document formats, such as PDF, BMP, TIFF and VB.NET guide for converting PowerPoint document to
change pdf to powerpoint online; how to convert pdf to powerpoint on
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
library SDK, this VB.NET PowerPoint processing control add PDF document, image to pdf files and for capturing, viewing, processing, converting, compressing and
converting pdf to powerpoint slides; how to convert pdf to powerpoint
C++ Primer, Fifth Edition
In the following example, we’ve defined two ways to obtain an A from a B: either by
using B’s conversion operator or by using the A constructor that takes a B:
Click here to view code image
// usually a bad idea to have mutual conversions between two class types
struct B;
struct A {
A() = default;
A(const B&);        // converts a B to an A
// other members
struct B {
operator A() const; // also converts a B to an A
// other members
A f(const A&);
B b;
A a = f(b); // error ambiguous: f(B::operator A())
//          or f(A::A(const B&))
Because there are two ways to obtain an A from a B, the compiler doesn’t know which
conversion to run; the call to f is ambiguous. This call can use the A constructor that
takes a B, or it can use the B conversion operator that converts a B to an A. Because
these two functions are equally good, the call is in error.
If we want to make this call, we have to explicitly call the conversion operator or
the constructor:
Click here to view code image
A a1 = f(b.operator A()); // ok: use B's conversion operator
A a2 = f(A(b));           // ok: use A's constructor
Note that we can’t resolve the ambiguity by using a cast—the cast itself would have
the same ambiguity.
Ambiguities and Multiple Conversions to Built-in Types
Ambiguities also occur when a class defines multiple conversions to (or from) types
that are themselves related by conversions. The easiest case to illustrate—and one
that is particularly problematic—is when a class defines constructors from or
conversions to more than one arithmetic type.
For example, the following class has converting constructors from two different
arithmetic types, and conversion operators to two different arithmetic types:
Click here to view code image
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
image, clip art or screenshot to PowerPoint document slide PDF document, image to pdf files and for capturing, viewing, processing, converting, compressing and
changing pdf to powerpoint file; converter pdf to powerpoint
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 document to powerpoint; convert pdf to powerpoint online no email
C++ Primer, Fifth Edition
struct A {
A(int = 0);   // usually a bad idea to have two
A(double);    // conversions from arithmetic types
operator int() const;    // usually a bad idea to have two
operator double() const; // conversions to arithmetic types
//   other members
void f2(long double);
A a;
f2(a); // error ambiguous: f(A::operator int())
//          or f(A::operator double())
long lg;
A a2(lg); // error ambiguous: A::A(int) or A::A(double)
In the call to f2, neither conversion is an exact match to long double. However,
either conversion can be used, followed by a standard conversion to get to long
double. Hence, neither conversion is better than the other; the call is ambiguous.
We encounter the same problem when we try to initialize a2 from a long. Neither
constructor is an exact match for long. Each would require that the argument be
converted before using the constructor:
• Standard long to double conversion followed by A(double)
• Standard long to int conversion followed by A(int)
These conversion sequences are indistinguishable, so the call is ambiguous.
The call to f2, and the initialization of a2, are ambiguous because the standard
conversions that were needed had the same rank (§ 6.6.1, p. 245). When a user-
defined conversion is used, the rank of the standard conversion, if any, is used to
select the best match:
Click here to view code image
short s = 42;
// promoting short to int is better than converting short to double
A a3(s);  // uses A::A(int)
In this case, promoting a short to an int is preferred to converting the short to a
double. Hence a3 is constructed using the A::A(int) constructor, which is run on
the (promoted) value of s.
When two user-defined conversions are used, the rank of the standard
conversion, if any, 
the conversion function is used to
select the best match.
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
users also can get the precise PowerPoint slides count as Save as local PowerPoint document file for capturing, viewing, processing, converting, compressing and
changing pdf to powerpoint; pdf into powerpoint
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
please read this VB.NET PowerPoint slide processing PDF document, image to pdf files and for capturing, viewing, processing, converting, compressing and
pdf to ppt converter; convert pdf to powerpoint with
C++ Primer, Fifth Edition
Overloaded Functions and Converting Constructors
Choosing among multiple conversions is further complicated when we call an
overloaded function. If two or more conversions provide a viable match, then the
conversions are considered equally good.
As one example, ambiguity problems can arise when overloaded functions take
parameters that differ by class types that define the same converting constructors:
Caution: Conversions and Operators
Correctly designing the overloaded operators, conversion constructors, and
conversion functions for a class requires some care. In particular, ambiguities
are easy to generate if a class defines both conversion operators and
overloaded operators. A few rules of thumb can be helpful:
• Don’t define mutually converting classes—if class Foo has a constructor
that takes an object of class Bar, do not give Bar a conversion operator to
type Foo.
• Avoid conversions to the built-in arithmetic types. In particular, if you do
define a conversion to an arithmetic type, then
– Do not define overloaded versions of the operators that take arithmetic
types. If users need to use these operators, the conversion operation will
convert objects of your type, and then the built-in operators can be used.
– Do not define a conversion to more than one arithmetic type. Let the
standard conversions provide conversions to the other arithmetic types.
The easiest rule of all: With the exception of an explicit conversion to
bool, avoid defining conversion functions and limit nonexplicit
constructors to those that are “obviously right.”
Click here to view code image
struct C {
// other members
struct D {
// other members
void manip(const C&);
void manip(const D&);
manip(10); // error ambiguous: manip(C(10)) or manip(D(10))
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
in VB.NET to finish PowerPoint document splitting you want to see more PDF processing functions for capturing, viewing, processing, converting, compressing and
how to change pdf to powerpoint on; how to convert pdf to ppt
C# Tiff Convert: How to Convert PowerPoint Document to Tiff Image
RasterEdge.XDoc.PDF.dll. C# Class Code for PowerPoint to Tiff Converting. provide an example of using C# class code to convert the whole PowerPoint document to
convert pdf to powerpoint presentation; convert pdf to powerpoint using
C++ Primer, Fifth Edition
Here both C and D have constructors that take an int. Either constructor can be used
to match a version of manip. Hence, the call is ambiguous: It could mean convert the
int to C and call the first version of manip, or it could mean convert the int to D
and call the second version.
The caller can disambiguate by explicitly constructing the correct type:
Click here to view code image
manip(C(10)); // ok: calls manip(const C&)
Needing to use a constructor or a cast to convert an argument in a call to an
overloaded function frequently is a sign of bad design.
Overloaded Functions and User-Defined Conversion
In a call to an overloaded function, if two (or more) user-defined conversions provide
a viable match, the conversions are considered equally good. The rank of any
standard conversions that might or might not be required is not considered. Whether a
built-in conversion is also needed is considered only if the overload set can be
using the same conversion function.
For example, our call to manip would be ambiguous even if one of the classes
defined a constructor that required a standard conversion for the argument:
Click here to view code image
struct E {
// other members
void manip2(const C&);
void manip2(const E&);
// error ambiguous: two different user-defined conversions could be used
manip2(10); // manip2(C(10) or manip2(E(double(10)))
In this case, C has a conversion from int and E has a conversion from double. For
the call manip2(10), both manip2 functions are viable:
• manip2(const C&) is viable because C has a converting constructor that
takes an int. That constructor is an exact match for the argument.
• manip2(const E&) is viable because E has a converting constructor that
takes a double and we can use a standard conversion to convert the int
argument in order to use that converting constructor.
C# PowerPoint: C# Guide to Add, Insert and Delete PPT Slide(s)
detailed guide for each PowerPoint slide processing profession imaging controls, PDF document, tiff capturing, viewing, processing, converting, compressing and
how to convert pdf into powerpoint slides; conversion of pdf into ppt
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
or delete any certain PowerPoint slide without & profession imaging controls, PDF document, tiff capturing, viewing, processing, converting, compressing and
pdf to ppt converter online for large; convert pdf slides to powerpoint
C++ Primer, Fifth Edition
Because calls to the overloaded functions require 
user-defined conversions
from one another, this call is ambiguous. In particular, even though one of the calls
requires a standard conversion and the other is an exact match, the compiler will still
flag this call as an error.
In a call to an overloaded function, the rank of an additional standard
conversion (if any) matters only if the viable functions require the same user-
defined conversion. If different user-defined conversions are needed, then the
call is ambiguous.
14.9.3. Function Matching and Overloaded Operators
Overloaded operators are overloaded functions. Normal function matching (§ 6.4, p.
233) is used to determine which operator—built-in or overloaded—to apply to a given
expression. However, when an operator function is used in an expression, the set of
candidate functions is broader than when we call a function using the call operator. If
a has a class type, the expression a 
b might be
Click here to view code image
a.operatorsym (b); // a has operatorsym as a member function
operatorsym(a, b); // operatorsym is an ordinary function
Unlike ordinary function calls, we cannot use the form of the call to distinquish
whether we’re calling a nonmember or a member function.
Exercises Section 14.9.2
Exercise 14.50: Show the possible class-type conversion sequences for the
initializations of ex1 and ex2. Explain whether the initializations are legal or
Click here to view code image
struct LongDouble {
LongDouble(double = 0.0);
operator double();
operator float();
LongDouble ldObj;
int ex1 = ldObj;
float ex2 = ldObj;
Exercise 14.51: Show the conversion sequences (if any) needed to call each
C++ Primer, Fifth Edition
version of calc and explain why the best viable function is selected.
Click here to view code image
void calc(int);
void calc(LongDouble);
double dval;
calc(dval); // which calc?
When we use an overloaded operator with an operand of class type, the candidate
functions include ordinary nonmember versions of that operator, as well as the built-in
versions of the operator. Moreover, if the left-hand operand has class type, the
overloaded versions of the operator, if any, defined by that class are also included.
When we call a named function, member and nonmember functions with the same
name do 
overload one another. There is no overloading because the syntax we
use to call a named function distinguishes between member and nonmember
functions. When a call is through an object of a class type (or through a reference or
pointer to such an object), then only the member functions of that class are
considered. When we use an overloaded operator in an expression, there is nothing to
indicate whether we’re using a member or nonmember function. Therefore, both
member and nonmember versions must be considered.
The set of candidate functions for an operator used in an expression can
contain both nonmember and member functions.
As an example, we’ll define an addition operator for our SmallInt class:
Click here to view code image
class SmallInt {
SmallInt operator+(const SmallInt&, const SmallInt&);
SmallInt(int = 0);                   // conversion from int
operator int() const { return val; } // conversion to int
std::size_t val;
We can use this class to add two SmallInts, but we will run into ambiguity problems
if we attempt to perform mixed-mode arithmetic:
Click here to view code image
SmallInt s1, s2;
C++ Primer, Fifth Edition
SmallInt s3 = s1 + s2;  // uses overloaded operator+
int i = s3 + 0;         // error: ambiguous
The first addition uses the overloaded version of + that takes two SmallInt values.
The second addition is ambiguous, because we can convert 0 to a SmallInt and use
the SmallInt version of +, or convert s3 to int and use the built-in addition
operator on ints.
Providing both conversion functions to an arithmetic type and overloaded
operators for the same class type may lead to ambiguities between the
overloaded operators and the built-in operators.
Exercises Section 14.9.3
Exercise 14.52: Which operator+, if any, is selected for each of the
addition expressions? List the candidate functions, the viable functions, and
the type conversions on the arguments for each viable function:
Click here to view code image
struct LongDouble {
// member operator+ for illustration purposes; + is usually a nonmember
LongDouble operator+(const SmallInt&);
// other members as in § 14.9.2 (p. 587)
LongDouble operator+(LongDouble&, double);
SmallInt si;
LongDouble ld;
ld = si + ld;
ld = ld + si;
Exercise 14.53: Given the definition of SmallInt on page 588, determine
whether the following addition expression is legal. If so, what addition
operator is used? If not, how might you change the code to make it legal?
SmallInt s1;
double d = s1 + 3.14;
Chapter Summary
An overloaded operator must either be a member of a class or have at least one
operand of class type. Overloaded operators have the same number of operands,
associativity, and precedence as the corresponding operator when applied to the built-
C++ Primer, Fifth Edition
in types. When an operator is defined as a member, its implicit this pointer is bound
to the first operand. The assignment, subscript, function-call, and arrow operators
must be class members.
Objects of classes that overload the function-call operator, operator(), are known
as “function objects.” Such objects are often used in combination with the standard
algorithms. Lambda expressions are succinct ways to define simple function-object
A class can define conversions to or from its type that are used automatically.
Nonexplicit constructors that can be called with a single argument define
conversions from the parameter type to the class type; nonexplicit conversion
operators define conversions from the class type to other types.
Defined Terms
call signature Represents the interface of a callable object. A call signature
includes the return type and a comma-separated list of argument types enclosed
in parentheses.
class-type conversion Conversions to or from class types are defined by
constructors and conversion operators, respectively. Nonexplicit constructors
that take a single argument define a conversion from the argument type to the
class type. Conversion operators define conversions from the class type to the
specified type.
conversion operator A member function that defines a conversions from the
class type to another type. A conversion operator must be a member of the class
from which it converts and is usually a const member. These operators have no
return type and take no parameters. They return a value convertible to the type
of the conversion operator. That is, operator int returns an int, operator
string returns a string, and so on.
explicit conversion operator Conversion operator preceeded by the explicit
keyword. Such operators are used for implicit conversions only in conditions.
function object Object of a class that defines an overloaded call operator.
Function objects can be used where functions are normally expected.
function table Container, often a map or a vector, that holds values that can
be called.
function template Library template that can represent any callable type.
overloaded operator Function that redefines the meaning of one of the built-in
operators. Overloaded operator functions have the name operator followed by
the symbol being defined. Overloaded operators must have at least one operand
of class type. Overloaded operators have the same precedence, associativity and
Documents you may be interested
Documents you may be interested