C++ Primer, Fifth Edition
QueryResult eval(const TextQuery &t) const
{ return q->eval(t); }
std::string rep() const { return q->rep(); }
private:
Query(std::shared_ptr<Query_base> query): q(query) { }
std::shared_ptr<Query_base> q;
};
We start by naming as friends the operators that create Query objects. These
operators need to be friends in order to use the private constructor.
In the public interface for Query, we declare, but cannot yet define, the
constructor that takes a string. That constructor creates a WordQuery object, so
we cannot define this constructor until we have defined the WordQuery class.
The other two public members represent the interface for Query_base. In each
case, the Query operation uses its Query_base pointer to call the respective (virtual)
Query_base operation. The actual version that is called is determined at run time
and will depend on the type of the object to which q points.
The 
Query
Output Operator
The output operator is a good example of how our overall query system works:
Click here to view code image
std::ostream &
operator<<(std::ostream &os, const Query &query)
{
// Query::rep makes a virtual call through its Query_base pointer to rep()
return os << query.rep();
}
When we print a Query, the output operator calls the (public) rep member of class
Query. That function makes a virtual call through its pointer member to the rep
member of the object to which this Query points. That is, when we write
Click here to view code image
Query andq = Query(sought1) & Query(sought2);
cout << andq << endl;
the output operator calls Query::rep on andq. Query::rep in turn makes a virtual
call through its Query_base pointer to the Query_base version of rep. Because
andq points to an AndQuery object, that call will run AndQuery::rep.
Exercises Section 15.9.2
Exercise 15.32: What happens when an object of type Query is copied,
moved, assigned, and destroyed?
www.it-ebooks.info
Pdf conversion 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
how to convert pdf file to powerpoint presentation; how to convert pdf to powerpoint
Pdf conversion 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
converting pdf to powerpoint online; table from pdf to powerpoint
C++ Primer, Fifth Edition
Exercise 15.33: What about objects of type Query_base?
15.9.3. The Derived Classes
The most interesting part of the classes derived from Query_base is how they are
represented. The WordQuery class is most straightforward. Its job is to hold the
search word.
The other classes operate on one or two operands. A NotQuery has a single
operand, and AndQuery and OrQuery have two operands. In each of these classes,
the operand(s) can be an object of any of the concrete classes derived from
Query_base: A NotQuery can be applied to a WordQuery, an AndQuery, an
OrQuery, or another NotQuery. To allow this flexibility, the operands must be stored
as pointers to Query_base. That way we can bind the pointer to whichever concrete
class we need.
However, rather than storing a Query_base pointer, our classes will themselves
use a Query object. Just as user code is simplified by using the interface class, we
can simplify our own class code by using the same class.
Now that we know the design for these classes, we can implement them.
The 
WordQuery
Class
A WordQuery looks for a given string. It is the only operation that actually
performs a query on the given TextQuery object:
Click here to view code image
class WordQuery: public Query_base {
friend class Query; // Query uses the WordQuery constructor
WordQuery(const std::string &s): query_word(s) { }
// concrete class: WordQuery defines all inherited pure virtual functions
QueryResult eval(const TextQuery &t) const
{ return t.query(query_word); }
std::string rep() const { return query_word; }
std::string query_word;    // word for which to search
};
Like Query_base, WordQuery has no public members; WordQuery must make
Query a friend in order to allow Query to access the WordQuery constructor.
Each of the concrete query classes must define the inherited pure virtual functions,
eval and rep. We defined both operations inside the WordQuery class body: eval
calls the query member of its given TextQuery parameter, which does the actual
search in the file; rep returns the string that this WordQuery represents (i.e.,
query_word).
www.it-ebooks.info
Online Convert PowerPoint to PDF file. Best free online export
area. Then just wait until the conversion from Powerpoint to PDF is complete and download the file. The perfect conversion tool.
convert pdf to powerpoint slide; add pdf to powerpoint presentation
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
And detailed C# demo codes for these conversions are offered below. C# Demo Codes for PowerPoint Conversions. PowerPoint to PDF Conversion.
add pdf to powerpoint slide; pdf to powerpoint conversion
C++ Primer, Fifth Edition
Having defined the WordQuery class, we can now define the Query constructor
that takes a string:
Click here to view code image
inline
Query::Query(const std::string &s): q(new WordQuery(s)) { }
This constructor allocates a WordQuery and initializes its pointer member to point to
that newly allocated object.
The 
NotQuery
Class and the 
~
Operator
The ~ operator generates a NotQuery, which holds a Query, which it negates:
Click here to view code image
class NotQuery: public Query_base {
friend Query operator~(const Query &);
NotQuery(const Query &q): query(q) { }
// concrete class: NotQuery defines all inherited pure virtual functions
std::string rep() const {return "~(" + query.rep() +
")";}
QueryResult eval(const TextQuery&) const;
Query query;
};
inline Query operator~(const Query &operand)
{
return 
std::shared_ptr<Query_base>(new
NotQuery(operand));
}
Because the members of NotQuery are all private, we start by making the ~
operator a friend. To rep a NotQuery, we concatenate the ~ symbol to the
representation of the underlying Query. We parenthesize the output to ensure that
precedence is clear to the reader.
It is worth noting that the call to rep in NotQuery’s own rep member ultimately
makes a virtual call to rep: query.rep() is a nonvirtual call to the rep member of
the Query class. Query::rep in turn calls q->rep(), which is a virtual call through
its Query_base pointer.
The ~ operator dynamically allocates a new NotQuery object. The return
(implicitly) uses the Query constructor that takes a shared_ptr<Query_base>.
That is, the return statement is equivalent to
Click here to view code image
// allocate a new NotQuery object
// bind the resulting NotQuery pointer to a shared_ptr<Query_base
shared_ptr<Query_base> tmp(new NotQuery(expr));
www.it-ebooks.info
.NET PDF Document Viewing, Annotation, Conversion & Processing
XDoc.PDF SDK for .NET. RasterEdge XDoc.PDF for .NET is a professional .NET PDF solution that provides complete and advanced PDF document processing features.
convert pdf to powerpoint online; convert pdf back to powerpoint
C# powerpoint - Convert PowerPoint to TIFF in C#.NET
Supported. Load, Save Document. Preview Document. Conversion. Convert PowerPoint to PDF. Convert PowerPoint to HTML5. Convert PowerPoint to
pdf picture to powerpoint; image from pdf to ppt
C++ Primer, Fifth Edition
return Query(tmp); // use the Query constructor that takes a shared_ptr
The eval member is complicated enough that we will implement it outside the class
body. We’ll define the eval functions in §15.9.4 (p. 647).
The 
BinaryQuery
Class
The BinaryQuery class is an abstract base class that holds the data needed by the
query types that operate on two operands:
Click here to view code image
class BinaryQuery: public Query_base {
protected:
BinaryQuery(const Query &l, const Query &r, std::string
s):
lhs(l), rhs(r), opSym(s) { }
// abstract class: BinaryQuery doesn't define eval
std::string rep() const { return "(" + lhs.rep() + " "
+ opSym + " "
+ rhs.rep() + ")";
}
Query lhs, rhs;    // right- and left-hand operands
std::string opSym; // name of the operator
};
The data in a BinaryQuery are the two Query operands and the corresponding
operator symbol. The constructor takes the two operands and the operator symbol,
each of which it stores in the corresponding data members.
To rep a BinaryOperator, we generate the parenthesized expression consisting
of the representation of the left-hand operand, followed by the operator, followed by
the representation of the right-hand operand. As when we displayed a NotQuery, the
calls to rep ultimately make virtual calls to the rep function of the Query_base
objects to which lhs and rhs point.
Note
The BinaryQuery class does not define the eval function and so inherits a
pure virtual. Thus, BinaryQuery is also an abstract base class, and we
cannot create objects of BinaryQuery type.
The 
AndQuery
and 
OrQuery
Classes and Associated Operators
The AndQuery and OrQuery classes, and their corresponding operators, are quite
similar to one another:
www.it-ebooks.info
How to C#: Overview of Using XDoc.PowerPoint
XDoc.PowerPoint for .NET, like PPTXDocument and PPTXPage. PowerPoint Conversion. XDoc.PowerPoint SDK for .NET empowers C# developers
convert pdf to powerpoint online no email; convert pdf to powerpoint with
C# powerpoint - Convert PowerPoint to PDF in C#.NET
PowerPoint to PDF Conversion Overview. RasterEdge XDoc.PowerPoint empowers your C#.NET application with advanced PowerPoint to PDF conversion functionality.
converter pdf to powerpoint; and paste pdf into powerpoint
C++ Primer, Fifth Edition
Click here to view code image
class AndQuery: public BinaryQuery {
friend Query operator& (const Query&, const Query&);
AndQuery(const Query &left, const Query &right):
BinaryQuery(left, right, "&") { }
// concrete class: AndQuery inherits rep and defines the remaining pure virtual
QueryResult eval(const TextQuery&) const;
};
inline Query operator&(const Query &lhs, const Query &rhs)
{
return std::shared_ptr<Query_base>(new AndQuery(lhs,
rhs));
}
class OrQuery: public BinaryQuery {
friend Query operator|(const Query&, const Query&);
OrQuery(const Query &left, const Query &right):
BinaryQuery(left, right, "|") { }
QueryResult eval(const TextQuery&) const;
};
inline Query operator|(const Query &lhs, const Query &rhs)
{
return std::shared_ptr<Query_base>(new OrQuery(lhs,
rhs));
}
These classes make the respective operator a friend and define a constructor to create
their BinaryQuery base part with the appropriate operator. They inherit the
BinaryQuery definition of rep, but each overrides the eval function.
Like the ~ operator, the & and | operators return a shared_ptr bound to a newly
allocated object of the corresponding type. That shared_ptr gets converted to
Query as part of the return statement in each of these operators.
Exercises Section 15.9.3
Exercise 15.34: For the expression built in Figure 15.3 (p. 638):
(a) List the constructors executed in processing that expression.
(b) List the calls to rep that are made from cout << q.
(c) List the calls to eval made from q.eval().
Exercise 15.35: Implement the Query and Query_base classes, including
a definition of rep but omitting the definition of eval.
Exercise 15.36: Put print statements in the constructors and rep members
and run your code to check your answers to (a) and (b) from the first
exercise.
Exercise 15.37: What changes would your classes need if the derived
classes had members of type shared_ptr<Query_base> rather than of
www.it-ebooks.info
VB.NET PDF Converter Library SDK to convert PDF to other file
Conversion of MS Office to PDF. This guide give a series of demo code directly for converting MicroSoft Office Word, Excel and PowerPoint document to PDF file
change pdf to ppt; convert pdf pages into powerpoint slides
C# PDF Converter Library SDK to convert PDF to other file formats
C#.NET PDF - PDF Conversion & Rendering SDK for C#.NET. A best C# PDF converter control for adobe PDF document conversion in Visual Studio .NET applications.
convert pdf file into ppt; export pdf to powerpoint
C++ Primer, Fifth Edition
type Query?
Exercise 15.38: Are the following declarations legal? If not, why not? If so,
explain what the declarations mean.
Click here to view code image
BinaryQuery a = Query("fiery") & Query("bird");
AndQuery b = Query("fiery") & Query("bird");
OrQuery c = Query("fiery") & Query("bird");
15.9.4. The eval Functions
The eval functions are the heart of our query system. Each of these functions calls
eval on its operand(s) and then applies its own logic: The OrQuery eval operation
returns the union of the results of its two operands; AndQuery returns the
intersection. The NotQuery is more complicated: It must return the line numbers that
are not in its operand’s set.
To support the processing in the eval functions, we need to use the version of
QueryResult that defines the members we added in the exercises to §12.3.2 (p.
490). We’ll assume that QueryResult has begin and end members that will let us
iterate through the set of line numbers that the QueryResult holds. We’ll also
assume that QueryResult has a member named get_file that returns a
shared_ptr to the underlying file on which the query was executed.
Warning
Our Query classes use members defined for QueryResult in the exercises
to §12.3.2 (p. 490).
OrQuery::eval
An OrQuery represents the union of the results for its two operands, which we obtain
by calling eval on each of its operands. Because these operands are Query objects,
calling eval is a call to Query::eval, which in turn makes a virtual call to eval on
the underlying Query_base object. Each of these calls yields a QueryResult
representing the line numbers in which its operand appears. We’ll combine those line
numbers into a new set:
Click here to view code image
// returns the union of its operands' result sets
QueryResult
OrQuery::eval(const TextQuery& text) const
www.it-ebooks.info
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document. Provide Free Demo Code for PDF Conversion from Microsoft PowerPoint in C# Program.
how to convert pdf to ppt; and paste pdf to powerpoint
VB.NET PowerPoint: Complete PowerPoint Document Conversion in VB.
resolution, bit depth, scaling, etc. Implement Conversion from PowerPoint to PDF in VB.NET, Converting PowerPoint document to PDF
image from pdf to powerpoint; how to convert pdf into powerpoint
C++ Primer, Fifth Edition
{
// virtual calls through the Query members, lhs and rhs
// the calls to eval return the QueryResult for each operand
auto right = rhs.eval(text), left = lhs.eval(text);
// copy the line numbers from the left-hand operand into the result set
auto ret_lines =
make_shared<set<line_no>>(left.begin(), left.end());
// insert lines from the right-hand operand
ret_lines->insert(right.begin(), right.end());
// return the new QueryResult representing the union of lhs and rhs
return QueryResult(rep(), ret_lines, left.get_file());
}
We initialize ret_lines using the set constructor that takes a pair of iterators. The
begin and end members of a QueryResult return iterators into that object’s set of
line numbers. So, ret_lines is created by copying the elements from left’s set.
We next call insert on ret_lines to insert the elements from right. After this
call, ret_lines contains the line numbers that appear in either left or right.
The eval function ends by building and returning a QueryResult representing the
combined match. The QueryResult constructor (§12.3.2, p. 489) takes three
arguments: a string representing the query, a shared_ptr to the set of matching
line numbers, and a shared_ptr to the vector that represents the input file. We
call rep to generate the string and get_file to obtain the shared_ptr to the
file. Because both left and right refer to the same file, it doesn’t matter which of
these we use for get_file.
AndQuery::eval
The AndQuery version of eval is similar to the OrQuery version, except that it calls
a library algorithm to find the lines in common to both queries:
Click here to view code image
// returns the intersection of its operands' result sets
QueryResult
AndQuery::eval(const TextQuery& text) const
{
// virtual calls through the Query operands to get result sets for the operands
auto left = lhs.eval(text), right = rhs.eval(text);
// set to hold the intersection of left and right
auto ret_lines = make_shared<set<line_no>>();
// writes the intersection of two ranges to a destination iterator
// destination iterator in this call adds elements to ret
set_intersection(left.begin(), left.end(),
right.begin(), right.end(),
inserter(*ret_lines, ret_lines-
>begin()));
return QueryResult(rep(), ret_lines, left.get_file());
www.it-ebooks.info
C++ Primer, Fifth Edition
}
Here we use the library set_intersection algorithm, which is described in
Appendix A.2.8 (p. 880), to merge these two sets.
The set_intersection algorithm takes five iterators. It uses the first four to
denote two input sequences (§10.5.2, p. 413). Its last argument denotes a
destination. The algorithm writes the elements that appear in both input sequences
into the destination.
In this call we pass an insert iterator (§10.4.1, p. 401) as the destination. When
set_intersection writes to this iterator, the effect will be to insert a new element
into ret_lines.
Like the OrQuery eval function, this one ends by building and returning a
QueryResult representing the combined match.
NotQuery::eval
NotQuery finds each line of the text within which the operand is not found:
Click here to view code image
// returns the lines not in its operand's result set
QueryResult
NotQuery::eval(const TextQuery& text) const
{
// virtual call to eval through the Query operand
auto result = query.eval(text);
// start out with an empty result set
auto ret_lines = make_shared<set<line_no>>();
// we have to iterate through the lines on which our operand appears
auto beg = result.begin(), end = result.end();
// for each line in the input file, if that line is not in result,
// add that line number to ret_lines
auto sz = result.get_file()->size();
for (size_t n = 0; n != sz; ++n) {
// if we haven't processed all the lines in result
// check whether this line is present
if (beg == end || *beg != n)
ret_lines->insert(n);  // if not in result, add this line
else if (beg != end)
++beg; // otherwise get the next line number in result if there is
one
}
return QueryResult(rep(), ret_lines, result.get_file());
}
As in the other eval functions, we start by calling eval on this object’s operand.
That call returns the QueryResult containing the line numbers on which the operand
www.it-ebooks.info
C++ Primer, Fifth Edition
appears, but we want the line numbers on which the operand does not appear. That
is, we want every line in the file that is not already in result.
We generate that set by iterating through sequenital integers up to the size of the
input file. We’ll put each number that is not in result into ret_lines. We position
beg and end to denote the first and one past the last elements in result. That
object is a set, so when we iterate through it, we’ll obtain the line numbers in
ascending order.
The loop body checks whether the current number is in result. If not, we add
that number to ret_lines. If the number is in result, we increment beg, which is
our iterator into result.
Once we’ve processed all the line numbers, we return a QueryResult containing
ret_lines, along with the results of running rep and get_file as in the previous
eval functions.
Exercises Section 15.9.4
Exercise 15.39: Implement the Query and Query_base classes. Test your
application by evaluating and printing a query such as the one in Figure 15.3
(p. 638).
Exercise 15.40: In the OrQuery eval function what would happen if its
rhs member returned an empty set? What if its lhs member did so? What if
both rhs and lhs returned empty sets?
Exercise 15.41: Reimplement your classes to use built-in pointers to
Query_base rather than shared_ptrs. Remember that your classes will no
longer be able to use the synthesized copy-control members.
Exercise 15.42: Design and implement one of the following enhancements:
(a) Print words only once per sentence rather than once per line.
(b) Introduce a history system in which the user can refer to a previous
query by number, possibly adding to it or combining it with another.
(c) Allow the user to limit the results so that only matches in a given range
of lines are displayed.
Chapter Summary
Inheritance lets us write new classes that share behavior with their base class(es) but
override or add to that behavior as needed. Dynamic binding lets us ignore type
differences by choosing, at run time, which version of a function to run based on an
object’s dynamic type. The combination of inheritance and dynamic binding lets us
write type-independent, programs that have type-specific behavior.
www.it-ebooks.info
C++ Primer, Fifth Edition
In C++, dynamic binding applies 
only
to functions declared as virtual and called
through a reference or pointer.
A derived-class object contains a subobject corresponding to each of its base
classes. Because every derived object contains a base part, we can convert a
reference or pointer to a derived-class type to a reference or pointer to an accessible
base class.
Inherited objects are constructed, copied, moved, and assigned by constructing,
copying, moving, and assigning the base part(s) of the object before handling the
derived part. Destructors execute in the opposite order; the derived type is destroyed
first, followed by destructors for the base-class subobjects. Base classes usually should
define a virtual destructor even if the class otherwise has no need for a destructor.
The destructor must be virtual if a pointer to a base is ever deleted when it actually
addresses a derived-class object.
A derived class specifies a protection level for each of its base class(es). Members
of a public base are part of the interface of the derived class; members of a
private base are inaccessible; members of a protected base are accessible to
classes that derive from the derived class but not to users of the derived class.
Defined Terms
abstract base class Class that has one or more pure virtual functions. We
cannot create objects of an abstract base-class type.
accessible Base class member that can be used through a derived object.
Accessibility depends on the access specifier used in derivation list of the derived
class and the access level of the member in the base class. For example, a
public member of a class that is inherited via public inheritance is accessible
to users of the derived class. A public base class member is inacceessible if the
inheritance is private.
base class Class from which other classes inherit. The members of the base
class become members of the derived class.
class derivation list List of base classes, each of which may have an optional
access level, from which a derived class inherits. If no access specifier is
provided, the inheritance is public if the derived class is defined with the
struct keyword, and is private if the class is defined with the class
keyword.
derived class Class that inherits from another class. A derived class can override
the virtuals of its base and can define new members. A derived-class scope is
nested in the scope of its base class(es); members of the derived class can use
members of the base class directly.
www.it-ebooks.info
Documents you may be interested
Documents you may be interested