C++ Primer, Fifth Edition
Now that the data members of Sales_data are private, our read, print, and
add functions will no longer compile. The problem is that although these functions are
part of the Sales_data interface, they are not members of the class.
A class can allow another class or function to access its nonpublic members by
making that class or function a friend. A class makes a function its friend by including
a declaration for that function preceded by the keyword friend:
Click here to view code image
class Sales_data {
// friend declarations for nonmember Sales_data operations added
friend Sales_data add(const Sales_data&, const Sales_data&);
friend std::istream &read(std::istream&, Sales_data&);
friend std::ostream &print(std::ostream&, const Sales_data&);
// other members and access specifiers as before
public:
Sales_data() = default;
Sales_data(const std::string &s, unsigned n, double p):
bookNo(s), units_sold(n), revenue(p*n) { }
Sales_data(const std::string &s): bookNo(s) { }
Sales_data(std::istream&);
std::string isbn() const { return bookNo; }
Sales_data &combine(const Sales_data&);
private:
std::string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};
// declarations for nonmember parts of the Sales_data interface
Sales_data add(const Sales_data&, const Sales_data&);
std::istream &read(std::istream&, Sales_data&);
std::ostream &print(std::ostream&, const Sales_data&);
Friend declarations may appear only inside a class definition; they may appear
anywhere in the class. Friends are not members of the class and are not affected by
the access control of the section in which they are declared. We’ll have more to say
about friendship in § 7.3.4 (p. 279).
Tip
Ordinarily it is a good idea to group friend declarations together at the
beginning or end of the class definition.
Key Concept: Benefits of Encapsulation
Encapsulation provides two important advantages:
www.it-ebooks.info
Changing pdf to powerpoint - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
add pdf to powerpoint presentation; change pdf to powerpoint on
Changing pdf 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
create powerpoint from pdf; and paste pdf to powerpoint
C++ Primer, Fifth Edition
• User code cannot inadvertently corrupt the state of an encapsulated object.
• The implementation of an encapsulated class can change over time without
requiring changes in user-level code.
By defining data members as private, the class author is free to make
changes in the data. If the implementation changes, only the class code
needs to be examined to see what effect the change may have. User code
needs to change only when the interface changes. If the data are public,
then any code that used the old data members might be broken. It would be
necessary to locate and rewrite any code that relied on the old representation
before the program could be used again.
Another advantage of making data members private is that the data are
protected from mistakes that users might introduce. If there is a bug that
corrupts an object’s state, the places to look for the bug are localized: Only
code that is part of the implementation could be responsible for the error.
The search for the mistake is limited, greatly easing the problems of
maintenance and program correctness.
Note
Although user code need not change when a class definition changes,
the source files that use a class must be recompiled any time the class
changes.
Declarations for Friends
A friend declaration only specifies access. It is not a general declaration of the
function. If we want users of the class to be able to call a friend function, then we
must also declare the function separately from the friend declaration.
To make a friend visible to users of the class, we usually declare each friend
(outside the class) in the same header as the class itself. Thus, our Sales_data
header should provide separate declarations (aside from the friend declarations inside
the class body) for read, print, and add.
Note
Many compilers do not enforce the rule that friend functions must be
declared 
outside
the class before they can be used.
www.it-ebooks.info
VB.NET Word: Word Conversion SDK for Changing Word Document into
VB.NET Word - Convert Word to PDF Using VB. How to Convert Word Document to PDF File in VB.NET Application. Visual C#. VB.NET. Home
converter pdf to powerpoint; convert pdf into ppt online
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Enable batch changing PDF page orientation without other PDF reader control. Support to overwrite PDF and save rotation changes to original PDF file.
convert pdf document to powerpoint; and paste pdf into powerpoint
C++ Primer, Fifth Edition
Some compilers allow calls to a friend function when there is no ordinary
declaration for that function. Even if your compiler allows such calls, it is a good idea
to provide separate declarations for friends. That way you won’t have to change
your code if you use a compiler that enforces this rule.
Exercises Section 7.2.1
Exercise 7.20: When are friends useful? Discuss the pros and cons of using
friends.
Exercise 7.21: Update your Sales_data class to hide its implementation.
The programs you’ve written to use Sales_data operations should still
continue to work. Recompile those programs with your new class definition to
verify that they still work.
Exercise 7.22: Update your Person class to hide its implementation.
7.3. Additional Class Features
The Sales_data class is pretty simple, yet it allowed us to explore quite a bit of the
language support for classes. In this section, we’ll cover some additional class-related
features that Sales_data doesn’t need to use. These features include type
members, in-class initializers for members of class type, mutable data members,
inline member functions, returning *this from a member function, more about
how we define and use class types, and class friendship.
7.3.1. Class Members Revisited
To explore several of these additional features, we’ll define a pair of cooperating
classes named Screen and Window_mgr.
Defining a Type Member
A Screen represents a window on a display. Each Screen has a string member
that holds the Screen’s contents, and three string::size_type members that
represent the position of the cursor, and the height and width of the screen.
In addition to defining data and function members, a class can define its own local
names for types. Type names defined by a class are subject to the same access
controls as any other member and may be either public or private:
Click here to view code image
www.it-ebooks.info
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
Merge Microsoft Office Word, Excel and PowerPoint data to PDF form. together and save as new PDF, without changing the previous two PDF documents at all
changing pdf to powerpoint; convert pdf slides to powerpoint
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
PDF. Supports tiff compression selection. Supports for changing image size. Also supports convert PDF files to jpg, jpeg images. C#
converting pdf to powerpoint slides; convert pdf to powerpoint
C++ Primer, Fifth Edition
class Screen {
public:
typedef std::string::size_type pos;
private:
pos cursor = 0;
pos height = 0, width = 0;
std::string contents;
};
We defined pos in the public part of Screen because we want users to use that
name. Users of Screen shouldn’t know that Screen uses a string to hold its data.
By defining pos as a public member, we can hide this detail of how Screen is
implemented.
There are two points to note about the declaration of pos. First, although we used
a typedef (§ 2.5.1, p. 67), we can equivalently use a type alias (§ 2.5.1, p. 68):
Click here to view code image
class Screen {
public:
// alternative way to declare a type member using a type alias
using pos = std::string::size_type;
// other members as before
};
The second point is that, for reasons we’ll explain in § 7.4.1 (p. 284), unlike ordinary
members, members that define types must appear before they are used. As a result,
type members usually appear at the beginning of the class.
Member Functions of class 
Screen
To make our class more useful, we’ll add a constructor that will let users define the
size and contents of the screen, along with members to move the cursor and to get
the character at a given location:
Click here to view code image
class Screen {
public:
typedef std::string::size_type pos;
Screen() = default; // needed because Screen has another constructor
// cursor initialized to 0 by its in-class initializer
Screen(pos ht, pos wd, char c): height(ht), width(wd),
contents(ht * wd, c) { }
char get() const              // get the character at the cursor
{ return contents[cursor]; }       // implicitly inline
inline char get(pos ht, pos wd) const; // explicitly inline
Screen &move(pos r, pos c);      // can be made inline later
private:
pos cursor = 0;
www.it-ebooks.info
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to perform PDF file password adding, deleting and changing in Visual Studio .NET project use C# source code in .NET class. Allow
changing pdf to powerpoint file; how to convert pdf to ppt online
C# TIFF: Learn to Convert MS Word, Excel, and PPT to TIFF Image
using RasterEdge.Imaging.PowerPoint; This demo code is for rendering and changing PowerPoint (.pptx) document to Tiff image. // Load your PPT (.pptx) document.
conversion of pdf to ppt online; convert pdf to powerpoint online no email
C++ Primer, Fifth Edition
pos height = 0, width = 0;
std::string contents;
};
Because we have provided a constructor, the compiler will not automatically generate
a default constructor for us. If our class is to have a default constructor, we must say
so explicitly. In this case, we use = default to ask the compiler to synthesize the
default constructor’s definition for us (§ 7.1.4, p. 264).
It’s also worth noting that our second constructor (that takes three arguments)
implicitly uses the in-class initializer for the cursor member (§ 7.1.4, p. 266). If our
class did not have an in-class initializer for cursor, we would have explicitly initialized
cursor along with the other members.
Making Members 
inline
Classes often have small functions that can benefit from being inlined. As we’ve seen,
member functions defined inside the class are automatically inline (§ 6.5.2, p. 238).
Thus, Screen’s constructors and the version of get that returns the character
denoted by the cursor are inline by default.
We can explicitly declare a member function as inline as part of its declaration
inside the class body. Alternatively, we can specify inline on the function definition
that appears outside the class body:
Click here to view code image
inline                   // we can specify inline on the definition
Screen &Screen::move(pos r, pos c)
{
pos row = r * width; // compute the row location
cursor = row + c ;   // move cursor to the column within that row
return *this;        // return this object as an lvalue
}
char Screen::get(pos r, pos c) const // declared as inline in the
class
{
pos row = r * width;      // compute row location
return contents[row + c]; // return character at the given column
}
Although we are not required to do so, it is legal to specify inline on both the
declaration and the definition. However, specifying inline only on the definition
outside the class can make the class easier to read.
Note
For the same reasons that we define inline functions in headers (§ 6.5.2,
www.it-ebooks.info
VB.NET Image: How to Generate Freehand Annotation Through VB.NET
as PDF, TIFF, PNG, BMP, etc. If this VB.NET annotation library is used, you are able to create freehand line annotation in VB.NET application without changing
adding pdf to powerpoint; how to change pdf to powerpoint on
VB.NET Image: Easy to Create Ellipse Annotation with VB.NET
png, gif & bmp; Add ellipse annotation to document files, like PDF & Word to customize ellipse annotation on your document or image by changing its parameters
convert pdf to powerpoint online; pdf to powerpoint slide
C++ Primer, Fifth Edition
p. 240), inline member functions should be defined in the same header as
the corresponding class definition.
Overloading Member Functions
As with nonmember functions, member functions may be overloaded (§ 6.4, p. 230)
so long as the functions differ by the number and/or types of parameters. The same
function-matching (§ 6.4, p. 233) process is used for calls to member functions as for
nonmember functions.
For example, our Screen class defined two versions of get. One version returns
the character currently denoted by the cursor; the other returns the character at a
given position specified by its row and column. The compiler uses the number of
arguments to determine which version to run:
Click here to view code image
Screen myscreen;
char ch = myscreen.get();// calls Screen::get()
ch = myscreen.get(0,0);  // calls Screen::get(pos, pos)
mutable
Data Members
It sometimes (but not very often) happens that a class has a data member that we
want to be able to modify, even inside a const member function. We indicate such
members by including the mutable keyword in their declaration.
mutable data member is never const, even when it is a member of a const
object. Accordingly, a const member function may change a mutable member. As
an example, we’ll give Screen a mutable member named access_ctr, which we’ll
use to track how often each Screen member function is called:
Click here to view code image
class Screen {
public:
void some_member() const;
private:
mutable size_t access_ctr; // may change even in a const object
// other members as before
};
void Screen::some_member() const
{
++access_ctr;    // keep a count of the calls to any member function
// whatever other work this member needs to do
}
www.it-ebooks.info
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
creating, loading, merge and splitting PDF pages and Files, adding a page into PDF document, deleting unnecessary page from PDF file and changing the position
convert pdf into ppt online; pdf to powerpoint conversion
C# Excel - Excel Page Processing Overview
C#.NET programming. Allow for changing the order of pages in an Excel document in .NET applications using C# language. Enable you
converting pdf to powerpoint; pdf to powerpoint converter online
C++ Primer, Fifth Edition
Despite the fact that some_member is a const member function, it can change the
value of access_ctr. That member is a mutable member, so any member
function, including const functions, can change its value.
Initializers for Data Members of Class Type
In addition to defining the Screen class, we’ll define a window manager class that
represents a collection of Screens on a given display. This class will have a vector
of Screens in which each element represents a particular Screen. By default, we’d
like our Window_mgr class to start up with a single, default-initialized Screen. Under
the new standard, the best way to specify this default value is as an in-class initializer
(§ 2.6.1, p. 73):
Click here to view code image
class Window_mgr {
private:
// Screens this Window_mgr is tracking
// by default, a Window_mgr has one standard sized blank Screen
std::vector<Screen> screens{Screen(24, 80, ' ') };
};
When we initialize a member of class type, we are supplying arguments to a
constructor of that member’s type. In this case, we list initialize our vector member
(§ 3.3.1, p. 98) with a single element initializer. That initializer contains a Screen
value that is passed to the vector<Screen> constructor to create a one-element
vector. That value is created by the Screen constructor that takes two size
parameters and a character to create a blank screen of the given size.
As we’ve seen, in-class initializers must use either the = form of initialization (which
we used when we initialized the the data members of Screen) or the direct form of
initialization using curly braces (as we do for screens).
Note
When we provide an in-class initializer, we must do so following an = sign or
inside braces.
Exercises Section 7.3.1
Exercise 7.23: Write your own version of the Screen class.
Exercise 7.24: Give your Screen class three constructors: a default
constructor; a constructor that takes values for height and width and
www.it-ebooks.info
C++ Primer, Fifth Edition
initializes the contents to hold the given number of blanks; and a constructor
that takes values for height, width, and a character to use as the contents of
the screen.
Exercise 7.25: Can Screen safely rely on the default versions of copy and
assignment? If so, why? If not, why not?
Exercise 7.26: Define Sales_data::avg_price as an inline function.
7.3.2. Functions That Return *this
Next we’ll add functions to set the character at the cursor or at a given location:
Click here to view code image
class Screen {
public:
Screen &set(char);
Screen &set(pos, pos, char);
// other members as before
};
inline Screen &Screen::set(char c)
{
contents[cursor] = c; // set the new value at the current cursor location
return *this;         // return this object as an lvalue
}
inline Screen &Screen::set(pos r, pos col, char ch)
{
contents[r*width + col] = ch;  // set specified location to given
value
return *this;                  // return this object as an lvalue
}
Like the move operation, our set members return a reference to the object on which
they are called (§ 7.1.2, p. 259). Functions that return a reference are lvalues (§
6.3.2, p. 226), which means that they return the object itself, not a copy of the
object. If we concatenate a sequence of these actions into a single expression:
Click here to view code image
// move the cursor to a given position, and set that character
myScreen.move(4,0).set('#');
these operations will execute on the same object. In this expression, we first move the
cursor inside myScreen and then set a character in myScreen’s contents
member. That is, this statement is equivalent to
myScreen.move(4,0);
www.it-ebooks.info
C++ Primer, Fifth Edition
myScreen.set('#');
Had we defined move and set to return Screen, rather than Screen&, this
statement would execute quite differently. In this case it would be equivalent to:
Click here to view code image
// if move returns Screen not Screen&
Screen temp = myScreen.move(4,0);  // the return value would be copied
temp.set('#'); // the contents inside myScreen would be unchanged
If move had a nonreference return type, then the return value of move would be a
copy of *this (§ 6.3.2, p. 224). The call to set would change the temporary copy,
not myScreen.
Returning 
*this
from a 
const
Member Function
Next, we’ll add an operation, which we’ll name display, to print the contents of the
Screen. We’d like to be able to include this operation in a sequence of set and
move operations. Therefore, like set and move, our display function will return a
reference to the object on which it executes.
Logically, displaying a Screen doesn’t change the object, so we should make
display a const member. If display is a const member, then this is a pointer
to const and *this is a const object. Hence, the return type of display must be
const Sales_data&. However, if display returns a reference to const, we won’t
be able to embed display into a series of actions:
Click here to view code image
Screen myScreen;
// if display returns a const reference, the call to set is an error
myScreen.display(cout).set('*');
Even though myScreen is a nonconst object, the call to set won’t compile. The
problem is that the const version of display returns a reference to const and we
cannot call set on a const object.
Note
A const member function that returns *this as a reference should have a
return type that is a reference to const.
Overloading Based on 
const
We can overload a member function based on whether it is const for the same
www.it-ebooks.info
C++ Primer, Fifth Edition
reasons that we can overload a function based on whether a pointer parameter points
to const (§ 6.4, p. 232). The nonconst version will not be viable for const objects;
we can only call const member functions on a const object. We can call either
version on a nonconst object, but the nonconst version will be a better match.
In this example, we’ll define a private member named do_display to do the
actual work of printing the Screen. Each of the display operations will call this
function and then return the object on which it is executing:
Click here to view code image
class Screen {
public:
// display overloaded on whether the object is const or not
Screen &display(std::ostream &os)
{ do_display(os); return *this; }
const Screen &display(std::ostream &os) const
{ do_display(os); return *this; }
private:
// function to do the work of displaying a Screen
void do_display(std::ostream &os) const {os <<
contents;}
// other members as before
};
As in any other context, when one member calls another the this pointer is passed
implicitly. Thus, when display calls do_display, its own this pointer is implicitly
passed to do_display. When the nonconst version of display calls
do_display, its this pointer is implicitly converted from a pointer to nonconst to
a pointer to const (§ 4.11.2, p. 162).
When do_display completes, the display functions each return the object on
which they execute by dereferencing this. In the nonconst version, this points to
a nonconst object, so that version of display returns an ordinary (nonconst)
reference; the const member returns a reference to const.
When we call display on an object, whether that object is const determines
which version of display is called:
Click here to view code image
Screen myScreen(5,3);
const Screen blank(5, 3);
myScreen.set('#').display(cout);   // calls non const version
blank.display(cout);               // calls const version
Advice: Use Private Utility Functions for Common Code
Some readers might be surprised that we bothered to define a separate
do_display operation. After all, the calls to do_display aren’t much
simpler than the action done inside do_display. Why bother? We do so for
www.it-ebooks.info
Documents you may be interested
Documents you may be interested