C++ Primer, Fifth Edition
parameters Local variables declared inside the function parameter list.
Parameters are initialized by the arguments provided in each function call.
pass by reference Description of how arguments are passed to parameters of
reference type. Reference parameters work the same way as any other use of
references; the parameter is bound to its corresponding argument.
pass by value How arguments are passed to parameters of a nonreference type.
A nonreference parameter is a copy of the value of its corresponding argument.
preprocessor macro Preprocessor facility that behaves like an inline function.
Aside from assert, modern C++ programs make very little use of preprocessor
macros.
recursion loop Description of a recursive function that omits a stopping
condition and which calls itself until exhasuting the program stack.
recursive function Function that calls itself directly or indirectly.
return type Part of a function declaration that specifies the type of the value
that the function returns.
separate compilation Ability to split a program into multiple separate source
files.
trailing return type Return type specified after the parameter list.
viable functions Subset of the candidate functions that could match a given call.
Viable functions have the same number of parameters as arguments to the call,
and each argument type can be converted to the corresponding parameter type.
() operator Call operator. Executes a function. The name of a function or a
function pointer precedes the parentheses, which enclose a (possibly empty)
comma-separated list of arguments.
Chapter 7. Classes
Contents
Section 7.1 Defining Abstract Data Types
Section 7.2 Access Control and Encapsulation
Section 7.3 Additional Class Features
Section 7.4 Class Scope
Section 7.5 Constructors Revisited
www.it-ebooks.info
Pdf to ppt - 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 to powerpoint online for; image from pdf to ppt
Pdf to ppt - 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
how to convert pdf to ppt; convert pdf to powerpoint presentation
C++ Primer, Fifth Edition
Section 7.6 static Class Members
Chapter Summary
Defined Terms
In C++ we use classes to define our own data types. By defining types that mirror
concepts in the problems we are trying to solve, we can make our programs easier to
write, debug, and modify.
This chapter continues the coverage of classes begun in Chapter 2. Here we will
focus on the importance of data abstraction, which lets us separate the
implementation of an object from the operations that that object can perform. In
Chapter 13 we’ll learn how to control what happens when objects are copied, moved,
assigned, or destroyed. In Chapter 14 we’ll learn how to define our own operators.
The fundamental ideas
behind classes are data abstraction and encapsulation.
Data abstraction is a programming (and design) technique that relies on the
separation of interface and implementation. The interface of a class consists of
the operations that users of the class can execute. The implementation includes the
class’ data members, the bodies of the functions that constitute the interface, and any
functions needed to define the class that are not intended for general use.
Encapsulation enforces the separation of a class’ interface and implementation. A
class that is encapsulated hides its implementation—users of the class can use the
interface but have no access to the implementation.
A class that uses data abstraction and encapsulation defines an abstract data
type. In an abstract data type, the class designer worries about how the class is
implemented. Programmers who use the class need not know how the type works.
They can instead think 
abstractly
about what the type does.
7.1. Defining Abstract Data Types
The Sales_item class that we used in Chapter 1 is an abstract data type. We use a
Sales_item object by using its interface (i.e., the operations described in § 1.5.1 (p.
20)). We have no access to the data members stored in a Sales_item object.
Indeed, we don’t even know what data members that class has.
Our Sales_data class (§ 2.6.1, p. 72) is not an abstract data type. It lets users of
the class access its data members and forces users to write their own operations. To
make Sales_data an abstract type, we need to define operations for users of
Sales_data to use. Once Sales_data defines its own operations, we can
encapsulate (that is, hide) its data members.
7.1.1. Designing the Sales_data Class
www.it-ebooks.info
Online Convert PowerPoint to PDF file. Best free online export
Creating a PDF from PPTX/PPT has never been so easy! Web Security. Your PDF and PPTX/PPT files will be deleted from our servers an hour after the conversion.
pdf into powerpoint; pdf to powerpoint converter online
How to C#: Convert PDF, Excel, PPT to Word
How to C#: Convert PDF, Excel, PPT to Word. Online C# Tutorial for Converting PDF, MS-Excel, MS-PPT to Word. PDF, MS-Excel, MS-PPT to Word Conversion Overview.
convert pdf to editable ppt; how to convert pdf to powerpoint
C++ Primer, Fifth Edition
Ultimately, we want Sales_data to support the same set of operations as the
Sales_item class. The Sales_item class had one member function (§ 1.5.2, p.
23), named isbn, and supported the +, =, +=, <<, and >> operators.
We’ll learn how to define our own operators in Chapter 14. For now, we’ll define
ordinary (named) functions for these operations. For reasons that we will explain in §
14.1 (p. 555), the functions that do addition and IO will not be members of
Sales_data. Instead, we’ll define those functions as ordinary functions. The function
that handles compound assignment will be a member, and for reasons we’ll explain in
§ 7.1.5 (p. 267), our class doesn’t need to define assignment.
Thus, the interface to Sales_data consists of the following operations:
• An isbn member function to return the object’s 
ISBN
• A combine member function to add one Sales_data object into another
• A function named add to add two Sales_data objects
• A read function to read data from an istream into a Sales_data object
• A print function to print the value of a Sales_data object on an ostream
Key Concept: Different Kinds of Programming Roles
Programmers tend to think about the people who will run their applications as
users.
Similarly a class designer designs and implements a class for 
users
of
that class. In this case, the user is a programmer, not the ultimate user of
the application.
When we refer to a 
user,
the context makes it clear which kind of user is
meant. If we speak of 
user code
or the 
user
of the Sales_data class, we
mean a programmer who is using a class. If we speak of the 
user
of the
bookstore application, we mean the manager of the store who is running the
application.
Note
C++ programmers tend to speak of 
users
interchangeably as users of
the application or users of a class.
In simple applications, the user of a class and the designer of the class
might be one and the same person. Even in such cases, it is useful to keep
the roles distinct. When we design the interface of a class, we should think
about how easy it will be to use the class. When we use the class, we
shouldn’t think about how the class works.
Authors of successful applications do a good job of understanding and
implementing the needs of the application’s users. Similarly, good class
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.
pdf to ppt converter online for large; converting pdf to ppt online
How to C#: Convert Word, Excel and PPT to PDF
How to C#: Convert Word, Excel and PPT to PDF. Online C# Tutorial for Converting MS Office Word, Excel and PowerPoint to PDF. How to C#: Convert PPT to PDF.
convert pdf to powerpoint with; converting pdf to powerpoint online
C++ Primer, Fifth Edition
designers pay close attention to the needs of the programmers who will use
the class. A well-designed class has an interface that is intuitive and easy to
use and has an implementation that is efficient enough for its intended use.
Using the Revised 
Sales_data
Class
Before we think about how to implement our class, let’s look at how we can use our
interface functions. As one example, we can use these functions to write a version of
the bookstore program from § 1.6 (p. 24) that works with Sales_data objects rather
than Sales_items:
Click here to view code image
Sales_data total;         // variable to hold the running sum
if (read(cin, total))  {  // read the first transaction
Sales_data trans;     // variable to hold data for the next transaction
while(read(cin, trans)) {      //  read the remaining transactions
if (total.isbn() == trans.isbn())   // check the isbns
total.combine(trans);  // update the running total
else {
print(cout, total) << endl;  // print the results
total = trans;               // process the next book
}
}
print(cout, total) << endl;          // print the last transaction
} else {                                 // there was no input
cerr << "No data?!" << endl;         // notify the user
}
We start by defining a Sales_data object to hold the running total. Inside the if
condition, we call read to read the first transaction into total. This condition works
like other loops we’ve written that used the >> operator. Like the >> operator, our
read function will return its stream parameter, which the condition checks (§ 4.11.2,
p. 162). If the read fails, we fall through to the else to print an error message.
If there are data to read, we define trans, which we’ll use to hold each
transaction. The condition in the while also checks the stream returned by read. So
long as the input operations in read succeed, the condition succeeds and we have
another transaction to process.
Inside the while, we call the isbn members of total and trans to fetch their
respective 
ISBN
s. If total and trans refer to the same book, we call combine to
add the components of trans into the running total in total. If trans represents a
new book, we call print to print the total for the previous book. Because print
returns a reference to its stream parameter, we can use the result of print as the
www.it-ebooks.info
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
VB.NET PowerPoint processing control add-on can do PPT creating, loading We are dedicated to provide powerful & profession imaging controls, PDF document, image
drag and drop pdf into powerpoint; how to change pdf to powerpoint slides
C# TIFF: Learn to Convert MS Word, Excel, and PPT to TIFF Image
C# TIFF - Conversion from Word, Excel, PPT to TIFF. Learn How to Change Load your PPT (.pptx) document. PPTXDocument doc = new PPTXDocument
convert pdf to editable powerpoint online; how to convert pdf into powerpoint presentation
C++ Primer, Fifth Edition
left-hand operand of the <<. We do so to print a newline following the output
generated by print. We next assign trans to total, thus setting up to process the
records for the next book in the file.
After we have exhausted the input, we have to remember to print the data for the
last transaction, which we do in the call to print following the while loop.
Exercises Section 7.1.1
Exercise 7.1: Write a version of the transaction-processing program from §
1.6 (p. 24) using the Sales_data class you defined for the exercises in §
2.6.1 (p. 72).
7.1.2. Defining the Revised Sales_data Class
Our revised class will have the same data members as the version we defined in §
2.6.1 (p. 72): bookNo, a string representing the 
ISBN
; units_sold, an unsigned
that says how many copies of the book were sold; and revenue, a double
representing the total revenue for those sales.
As we’ve seen, our class will also have two member functions, combine and isbn.
In addition, we’ll give Sales_data another member function to return the average
price at which the books were sold. This function, which we’ll name avg_price, isn’t
intended for general use. It will be part of the implementation, not part of the
interface.
We define (§ 6.1, p. 202) and declare (§ 6.1.2, p. 206) member functions similarly
to ordinary functions. Member functions 
must
be declared inside the class. Member
functions 
may
be defined inside the class itself or outside the class body. Nonmember
functions that are part of the interface, such as add, read, and print, are declared
and defined outside the class.
With this knowledge, we’re ready to write our revised version of Sales_data:
Click here to view code image
struct Sales_data {
// new members: operations on Sales_data objects
std::string isbn() const { return bookNo; }
Sales_data& combine(const Sales_data&);
double avg_price() const;
// data members are unchanged from § 2.6.1 (p. 72)
std::string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};
www.it-ebooks.info
VB.NET PowerPoint: Convert & Render PPT into PDF Document
VB.NET PowerPoint - Render PPT to PDF in VB.NET. What VB.NET demo code can I use for fast PPT (.pptx) to PDF conversion in .NET class application?
image from pdf to powerpoint; change pdf to ppt
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
VB.NET PPT PDF-417 barcode scanning SDK to detect PDF-417 barcode image from PowerPoint slide. VB.NET APIs to detect and decode
how to convert pdf slides to powerpoint; pdf conversion to powerpoint
C++ Primer, Fifth Edition
// nonmember Sales_data interface functions
Sales_data add(const Sales_data&, const Sales_data&);
std::ostream &print(std::ostream&, const Sales_data&);
std::istream &read(std::istream&, Sales_data&);
Note
Functions defined in the class are implicitly inline (§ 6.5.2, p. 238).
Defining Member Functions
Although every member must be declared inside its class, we can define a member
function’s body either inside or outside of the class body. In Sales_data, isbn is
defined inside the class; combine and avg_price will be defined elsewhere.
We’ll start by explaining the isbn function, which returns a string and has an
empty parameter list:
Click here to view code image
std::string isbn() const { return bookNo; }
As with any function, the body of a member function is a block. In this case, the block
contains a single return statement that returns the bookNo data member of a
Sales_data object. The interesting thing about this function is how it gets the object
from which to fetch the bookNo member.
Introducing 
this
Let’s look again at a call to the isbn member function:
total.isbn()
Here we use the dot operator (§ 4.6, p. 150) to fetch the isbn member of the object
named total, which we then call.
With one exception that we’ll cover in § 7.6 (p. 300), when we call a member
function we do so on behalf of an object. When isbn refers to members of
Sales_data (e.g., bookNo), it is referring implicitly to the members of the object on
which the function was called. In this call, when isbn returns bookNo, it is implicitly
returning total.bookNo.
Member functions access the object on which they were called through an extra,
implicit parameter named this. When we call a member function, this is initialized
with the address of the object on which the function was invoked. For example, when
we call
www.it-ebooks.info
C++ Primer, Fifth Edition
total.isbn()
the compiler passes the address of total to the implicit this parameter in isbn. It
is as if the compiler rewrites this call as
Click here to view code image
// pseudo-code illustration of how a call to a member function is translated
Sales_data::isbn(&total)
which calls the isbn member of Sales_data passing the address of total.
Inside a member function, we can refer directly to the members of the object on
which the function was called. We do not have to use a member access operator to
use the members of the object to which this points. Any direct use of a member of
the class is assumed to be an implicit reference through this. That is, when isbn
uses bookNo, it is implicitly using the member to which this points. It is as if we
had written this->bookNo.
The this parameter is defined for us implicitly. Indeed, it is illegal for us to define
a parameter or variable named this. Inside the body of a member function, we can
use this. It would be legal, although unnecessary, to define isbn as
Click here to view code image
std::string isbn() const { return this->bookNo; }
Because this is intended to always refer to “this” object, this is a const pointer
(§ 2.4.2, p. 62). We cannot change the address that this holds.
Introducing 
const
Member Functions
The other important part about the isbn function is the keyword const that follows
the parameter list. The purpose of that const is to modify the type of the implicit
this pointer.
By default, the type of this is a const pointer to the nonconst version of the
class type. For example, by default, the type of this in a Sales_data member
function is Sales_data *const. Although this is implicit, it follows the normal
initialization rules, which means that (by default) we cannot bind this to a const
object (§ 2.4.2, p. 62). This fact, in turn, means that we cannot call an ordinary
member function on a const object.
If isbn were an ordinary function and if this were an ordinary pointer parameter,
we would declare this as const Sales_data *const. After all, the body of isbn
doesn’t change the object to which this points, so our function would be more
flexible if this were a pointer to const (§ 6.2.3, p. 213).
However, this is implicit and does not appear in the parameter list. There is no
place to indicate that this should be a pointer to const. The language resolves this
www.it-ebooks.info
C++ Primer, Fifth Edition
problem by letting us put const after the parameter list of a member function. A
const following the parameter list indicates that this is a pointer to const. Member
functions that use const in this way are const member functions.
We can think of the body of isbn as if it were written as
Click here to view code image
// pseudo-code illustration of how the implicit this pointer is used
// this code is illegal: we may not explicitly define the this pointer ourselves
// note that this is a pointer to const because isbn is a const member
std::string Sales_data::isbn(const Sales_data *const this)
{ return this->isbn; }
The fact that this is a pointer to const means that const member functions
cannot change the object on which they are called. Thus, isbn may read but not
write to the data members of the objects on which it is called.
Note
Objects that are const, and references or pointers to const objects, may
call only const member functions.
Class Scope and Member Functions
Recall that a class is itself a scope (§ 2.6.1, p. 72). The definitions of the member
functions of a class are nested inside the scope of the class itself. Hence, isbn’s use
of the name bookNo is resolved as the data member defined inside Sales_data.
It is worth noting that isbn can use bookNo even though bookNo is defined 
after
isbn. As we’ll see in § 7.4.1 (p. 283), the compiler processes classes in two steps—
the member declarations are compiled first, after which the member function bodies, if
any, are processed. Thus, member function bodies may use other members of their
class regardless of where in the class those members appear.
Defining a Member Function outside the Class
As with any other function, when we define a member function outside the class body,
the member’s definition must match its declaration. That is, the return type,
parameter list, and name must match the declaration in the class body. If the member
was declared as a const member function, then the definition must also specify
const after the parameter list. The name of a member defined outside the class must
include the name of the class of which it is a member:
Click here to view code image
www.it-ebooks.info
C++ Primer, Fifth Edition
double Sales_data::avg_price() const {
if (units_sold)
return revenue/units_sold;
else
return 0;
}
The function name, Sales_data::avg_price, uses the scope operator (§ 1.2, p. 8)
to say that we are defining the function named avg_price that is declared in the
scope of the Sales_data class. Once the compiler sees the function name, the rest
of the code is interpreted as being inside the scope of the class. Thus, when
avg_price refers to revenue and units_sold, it is implicitly referring to the
members of Sales_data.
Defining a Function to Return “This” Object
The combine function is intended to act like the compound assignment operator, +=.
The object on which this function is called represents the left-hand operand of the
assignment. The right-hand operand is passed as an explicit argument:
Click here to view code image
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
units_sold += rhs.units_sold; // add the members of rhs into
revenue += rhs.revenue;       // the members of ''this'' object
return *this; // return the object on which the function was called
}
When our transaction-processing program calls
Click here to view code image
total.combine(trans); // update the running total
the address of total is bound to the implicit this parameter and rhs is bound to
trans. Thus, when combine executes
Click here to view code image
units_sold += rhs.units_sold; // add the members of rhs into
the effect is to add total.units_sold and trans.units_sold, storing the result
back into total.units_sold.
The interesting part about this function is its return type and the return
statement. Ordinarily, when we define a function that operates like a built-in operator,
our function should mimic the behavior of that operator. The built-in assignment
operators return their left-hand operand as an lvalue (§ 4.4, p. 144). To return an
lvalue, our combine function must return a reference (§ 6.3.2, p. 226). Because the
left-hand operand is a Sales_data object, the return type is Sales_data&.
www.it-ebooks.info
C++ Primer, Fifth Edition
As we’ve seen, we do not need to use the implicit this pointer to access the
members of the object on which a member function is executing. However, we do
need to use this to access the object as a whole:
Click here to view code image
return *this; // return the object on which the function was called
Here the return statement dereferences this to obtain the object on which the
function is executing. That is, for the call above, we return a reference to total.
Exercises Section 7.1.2
Exercise 7.2: Add the combine and isbn members to the Sales_data
class you wrote for the exercises in § 2.6.2 (p. 76).
Exercise 7.3: Revise your transaction-processing program from § 7.1.1 (p.
256) to use these members.
Exercise 7.4: Write a class named Person that represents the name and
address of a person. Use a string to hold each of these elements.
Subsequent exercises will incrementally add features to this class.
Exercise 7.5: Provide operations in your Person class to return the name
and address. Should these functions be const? Explain your choice.
7.1.3. Defining Nonmember Class-Related Functions
Class authors often define auxiliary functions, such as our add, read, and print
functions. Although such functions define operations that are conceptually part of the
interface of the class, they are not part of the class itself.
We define nonmember functions as we would any other function. As with any other
function, we normally separate the declaration of the function from its definition (§
6.1.2, p. 206). Functions that are conceptually part of a class, but not defined inside
the class, are typically declared (but not defined) in the same header as the class
itself. That way users need to include only one file to use any part of the interface.
Note
Ordinarily, nonmember functions that are part of the interface of a class
should be declared in the same header as the class itself.
Defining the 
read
and 
print
Functions
www.it-ebooks.info
Documents you may be interested
Documents you may be interested