C++ Primer, Fifth Edition
several reasons:
• A general desire to avoid writing the same code in more than one place.
• We expect that the display operation will become more complicated as
our class evolves. As the actions involved become more complicated, it
makes more obvious sense to write those actions in one place, not two.
• It is likely that we might want to add debugging information to
do_display during development that would be eliminated in the final
product version of the code. It will be easier to do so if only one definition
of do_display needs to be changed to add or remove the debugging
• There needn’t be any overhead involved in this extra function call. We
defined do_display inside the class body, so it is implicitly inline. Thus,
there likely be no run-time overhead associating with calling do_display.
In practice, well-designed C++ programs tend to have lots of small functions
such as do_display that are called to do the “real” work of some other set
of functions.
7.3.3. Class Types
Every class defines a unique type. Two different classes define two different types
even if they define the same members. For example:
Exercises Section 7.3.2
Exercise 7.27: Add the move, set, and display operations to your
version of Screen. Test your class by executing the following code:
Click here to view code image
Screen myScreen(5, 5, 'X');
cout << "\n";
cout << "\n";
Exercise 7.28: What would happen in the previous exercise if the return
type of move, set, and display was Screen rather than Screen&?
Exercise 7.29: Revise your Screen class so that move, set, and display
functions return Screen and check your prediction from the previous
Exercise 7.30: It is legal but redundant to refer to members through the
this pointer. Discuss the pros and cons of explicitly using the this pointer
to access members.
Embed pdf into 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
convert pdf pages into powerpoint slides; add pdf to powerpoint slide
Embed pdf into 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
how to convert pdf into powerpoint slides; pdf page to powerpoint
C++ Primer, Fifth Edition
Click here to view code image
struct First {
int memi;
int getMem();
struct Second {
int memi;
int getMem();
First obj1;
Second obj2 = obj1; // error: obj1 and obj2 have different types
Even if two classes have exactly the same member list, they are different
types. The members of each class are distinct from the members of any
other class (or any other scope).
We can refer to a class type directly, by using the class name as a type name.
Alternatively, we can use the class name following the keyword class or struct:
Click here to view code image
Sales_data item1;       // default-initialized object of type Sales_data
class Sales_data item1; // equivalent declaration
Both methods of referring to a class type are equivalent. The second method is
inherited from C and is also valid in C++.
Class Declarations
Just as we can declare a function apart from its definition (§ 6.1.2, p. 206), we can
also declare a class without defining it:
Click here to view code image
class Screen; // declaration of the Screen class
This declaration, sometimes referred to as a forward declaration, introduces the
name Screen into the program and indicates that Screen refers to a class type.
After a declaration and before a definition is seen, the type Screen is an incomplete
type—it’s known that Screen is a class type but not known what members that type
We can use an incomplete type in only limited ways: We can define pointers or
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Embed PDF hyperlinks to HTML links. also makes PDF document visible and searchable on the Internet by converting PDF document file into HTML webpage.
how to convert pdf to powerpoint slides; convert pdf to powerpoint slides
C# TIFF: How to Embed, Remove, Add and Update TIFF Color Profile
On the whole, our SDK supports the following manipulations. Empower C# programmers to embed, remove, add and update ICCProfile. Support
export pdf to powerpoint; convert pdf to editable ppt
C++ Primer, Fifth Edition
references to such types, and we can declare (but not define) functions that use an
incomplete type as a parameter or return type.
A class must be defined—not just declared—before we can write code that creates
objects of that type. Otherwise, the compiler does not know how much storage such
objects need. Similarly, the class must be defined before a reference or pointer is used
to access a member of the type. After all, if the class has not been defined, the
compiler can’t know what members the class has.
With one exception that we’ll describe in § 7.6 (p. 300), data members can be
specified to be of a class type only if the class has been defined. The type must be
complete because the compiler needs to know how much storage the data member
requires. Because a class is not defined until its class body is complete, a class cannot
have data members of its own type. However, a class is considered declared (but not
yet defined) as soon as its class name has been seen. Therefore, a class can have
data members that are pointers or references to its own type:
class Link_screen {
Screen window;
Link_screen *next;
Link_screen *prev;
Exercises Section 7.3.3
Exercise 7.31: Define a pair of classes X and Y, in which X has a pointer to
Y, and Y has an object of type X.
7.3.4. Friendship Revisited
Our Sales_data class defined three ordinary nonmember functions as friends (§
7.2.1, p. 269). A class can also make another class its friend or it can declare specific
member functions of another (previously defined) class as friends. In addition, a friend
function can be defined inside the class body. Such functions are implicitly inline.
Friendship between Classes
As an example of class friendship, our Window_mgr class (§ 7.3.1, p. 274) will have
members that will need access to the internal data of the Screen objects it manages.
For example, let’s assume that we want to add a member, named clear to
Window_mgr that will reset the contents of a particular Screen to all blanks. To do
this job, clear needs to access the private data members of Screen. To allow this
access, Screen can designate Window_mgr as its friend:
Click here to view code image
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Available zoom setting (fit page, fit width).
how to convert pdf to powerpoint; convert pdf to powerpoint presentation
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Embed PDF to image converter in viewer. Quick evaluation source codes for VB.NET class. Sometimes, to convert PDF document into BMP, GIF, JPEG and PNG
converting pdf to ppt; embed pdf into powerpoint
C++ Primer, Fifth Edition
class Screen {
// Window_mgr members can access the private parts of class Screen
friend class Window_mgr;
// ... rest of the Screen class
The member functions of a friend class can access all the members, including the
nonpublic members, of the class granting friendship. Now that Window_mgr is a
friend of Screen, we can write the clear member of Window_mgr as follows:
Click here to view code image
class Window_mgr {
// location ID for each screen on the window
using ScreenIndex = std::vector<Screen>::size_type;
// reset the Screen at the given position to all blanks
void clear(ScreenIndex);
std::vector<Screen> screens{Screen(24, 80, ' ')};
void Window_mgr::clear(ScreenIndex i)
// s is a reference to the Screen we want to clear
Screen &s = screens[i];
// reset the contents of that Screen to all blanks
s.contents = string(s.height * s.width, ' ');
We start by defining s as a reference to the Screen at position i in the screens
vector. We then use the height and width members of that Screen to compute
anew string that has the appropriate number of blank characters. We assign that
string of blanks to the contents member.
If clear were not a friend of Screen, this code would not compile. The clear
function would not be allowed to use the height width, or contents members of
Screen. Because Screen grants friendship to Window_mgr, all the members of
Screen are accessible to the functions in Window_mgr.
It is important to understand that friendship is not transitive. That is, if class
Window_mgr has its own friends, those friends have no special access to Screen.
Each class controls which classes or functions are its friends.
Making A Member Function a Friend
C# Raster - Image Save Options in C#.NET
NET Read: PDF Image Extract; VB.NET Write: Insert text into PDF; VB.NET How-to, VB.NET PDF, VB.NET Word, VB a zone bit of whether it's need to embed Color profile
how to convert pdf slides to powerpoint presentation; convert pdf to editable powerpoint online
C# TIFF: How to Insert & Burn Picture/Image into TIFF Document
Entire C# Code to Embed and Burn Image to TIFF GetPage(0); // load an PNG logo into REImage REImage powerful & profession imaging controls, PDF document, tiff
how to add pdf to powerpoint; changing pdf to powerpoint
C++ Primer, Fifth Edition
Rather than making the entire Window_mgr class a friend, Screen can instead
specify that only the clear member is allowed access. When we declare a member
function to be a friend, we must specify the class of which that function is a member:
Click here to view code image
class Screen {
// Window_mgr::clear must have been declared before class Screen
friend void Window_mgr::clear(ScreenIndex);
// ... rest of the Screen class
Making a member function a friend requires careful structuring of our programs to
accommodate interdependencies among the declarations and definitions. In this
example, we must order our program as follows:
• First, define the Window_mgr class, which declares, but cannot define, clear.
Screen must be declared before clear can use the members of Screen.
• Next, define class Screen, including a friend declaration for clear.
• Finally, define clear, which can now refer to the members in Screen.
Overloaded Functions and Friendship
Although overloaded functions share a common name, they are still different
functions. Therefore, a class must declare as a friend each function in a set of
overloaded functions that it wishes to make a friend:
Click here to view code image
// overloaded storeOn functions
extern std::ostream& storeOn(std::ostream &, Screen &);
extern BitMap& storeOn(BitMap &, Screen &);
class Screen {
// ostream version of storeOn may access the private parts of
Screen objects
friend std::ostream& storeOn(std::ostream &, Screen &);
// . . .
Class Screen makes the version of storeOn that takes an ostream& its friend. The
version that takes a BitMap& has no special access to Screen.
Friend Declarations and Scope
Classes and nonmember functions need not have been declared before they are used
in a friend declaration. When a name first appears in a friend declaration, that name
is implicitly 
to be part of the surrounding scope. However, the friend itself is
not actually declared in that scope (§ 7.2.1, p. 270).
VB.NET TIFF: Rotate TIFF Page by Using RaterEdge .NET TIFF
formats are: JPEG, PNG, GIF, BMP, PDF, Word (Docx Visual Basic .NET class, and then embed "RasterEdge.Imaging splitting huge target TIFF file into multiple and
how to change pdf file to powerpoint; conversion of pdf into ppt
VB.NET Image: How to Draw and Cutomize Text Annotation on Image
NET text annotation add-on tutorial can be divided into a few on document files in VB.NET, including PDF, TIFF & license and at last you can embed the required
add pdf to powerpoint; image from pdf to powerpoint
C++ Primer, Fifth Edition
Even if we define the function inside the class, we must still provide a declaration
outside of the class itself to make that function visible. A declaration must exist even if
we only call the friend from members of the friendship granting class:
Click here to view code image
struct X {
friend void f() { /* friend function can be defined in the class
body   */ }
X() { f(); } // error: no declaration for f
void g();
void h();
void X::g() { return f(); } // error: f hasn't been declared
void f();                   // declares the function defined inside X
void X::h() { return f(); } // ok: declaration for f is now in scope
It is important to understand that a friend declaration affects access but is not a
declaration in an ordinary sense.
Remember, some compilers do not enforce the lookup rules for friends (§
7.2.1, p. 270).
Exercises Section 7.3.4
Exercise 7.32: Define your own versions of Screen and Window_mgr in
which clear is a member of Window_mgr and a friend of Screen.
7.4. Class Scope
Every class defines its own new scope. Outside the class scope, ordinary data and
function members may be accessed only through an object, a reference, or a pointer
using a member access operator (§ 4.6, p. 150). We access type members from the
class using the scope operator . In either case, the name that follows the operator
must be a member of the associated class.
Click here to view code image
Screen::pos ht = 24, wd = 80; // use the pos type defined by Screen
Screen scr(ht, wd, ' ');
VB.NET Image: VB.NET Code to Add Rubber Stamp Annotation to Image
Suitable for VB.NET PDF, Word & TIFF document managing & editing project. VB Can be implemented into both Windows and web VB.NET applications; Support single or
convert pdf to editable ppt online; change pdf to powerpoint on
VB.NET Image: Creating Hotspot Annotation for Visual Basic .NET
the configuration environment to integrate RasterEdge Visual Basic .NET into your imaging to provide powerful & profession imaging controls, PDF document, tiff
how to add pdf to powerpoint slide; convert pdf to powerpoint online no email
C++ Primer, Fifth Edition
Screen *p = &scr;
char c = scr.get(); // fetches the get member from the object scr
c = p->get();       // fetches the get member from the object to which p
Scope and Members Defined outside the Class
The fact that a class is a scope explains why we must provide the class name as well
as the function name when we define a member function outside its class (§ 7.1.2, p.
259). Outside of the class, the names of the members are hidden.
Once the class name is seen, the remainder of the definition—including the parameter
list and the function body—is in the scope of the class. As a result, we can refer to
other class members without qualification.
For example, recall the clear member of class Window_mgr (§ 7.3.4, p. 280). That
function’s parameter uses a type that is defined by Window_mgr:
Click here to view code image
void Window_mgr::clear(ScreenIndex i)
Screen &s = screens[i];
s.contents = string(s.height * s.width, ' ');
Because the compiler sees the parameter list after noting that we are in the scope of
class WindowMgr, there is no need to specify that we want the ScreenIndex that is
defined by WindowMgr. For the same reason, the use of screens in the function
body refers to name declared inside class Window_mgr.
On the other hand, the return type of a function normally appears before the
function’s name. When a member function is defined outside the class body, any
name used in the return type is outside the class scope. As a result, the return type
must specify the class of which it is a member. For example, we might give
Window_mgr a function, named addScreen, to add another screen to the display.
This member will return a ScreenIndex value that the user can subsequently use to
locate this Screen:
Click here to view code image
class Window_mgr {
// add a Screen to the window and returns its index
ScreenIndex addScreen(const Screen&);
// other members as before
// return type is seen before we're in the scope of Window_mgr
Window_mgr::addScreen(const Screen &s)
C++ Primer, Fifth Edition
return screens.size() - 1;
Because the return type appears before the name of the class is seen, it appears
outside the scope of class Window_mgr. To use ScreenIndex for the return type,
we must specify the class in which that type is defined.
Exercises Section 7.4
Exercise 7.33: What would happen if we gave Screen a size member
defined as follows? Fix any problems you identify.
Click here to view code image
pos Screen::size() const
return height * width;
7.4.1. Name Lookup and Class Scope
In the programs we’ve written so far, name lookup (the process of finding which
declarations match the use of a name) has been relatively straightforward:
• First, look for a declaration of the name in the block in which the name was
used. Only names declared before the use are considered.
• If the name isn’t found, look in the enclosing scope(s).
• If no declaration is found, then the program is in error.
The way names are resolved inside member functions defined inside the class may
seem to behave differently than these lookup rules. However, in this case,
appearances are deceiving. Class definitions are processed in two phases:
• First, the member declarations are compiled.
• Function bodies are compiled only after the entire class has been seen.
Member function definitions are processed 
the compiler processes all of
the declarations in the class.
Classes are processed in this two-phase way to make it easier to organize class
C++ Primer, Fifth Edition
code. Because member function bodies are not processed until the entire class is
seen, they can use any name defined inside the class. If function definitions were
processed at the same time as the member declarations, then we would have to order
the member functions so that they referred only to names already seen.
Name Lookup for Class Member Declarations
This two-step process applies only to names used in the body of a member function.
Names used in declarations, including names used for the return type and types in the
parameter list, must be seen before they are used. If a member declaration uses a
name that has not yet been seen inside the class, the compiler will look for that name
in the scope(s) in which the class is defined. For example:
Click here to view code image
typedef double Money;
string bal;
class Account {
Money balance() { return bal; }
Money bal;
// ...
When the compiler sees the declaration of the balance function, it will look for a
declaration of Money in the Account class. The compiler considers only declarations
inside Account that appear before the use of Money. Because no matching member
is found, the compiler then looks for a declaration in the enclosing scope(s). In this
example, the compiler will find the typedef of Money. That type will be used for the
return type of the function balance and as the type for the data member bal. On
the other hand, the function body of balance is processed only after the entire class
is seen. Thus, the return inside that function returns the member named bal, not
the string from the outer scope.
Type Names Are Special
Ordinarily, an inner scope can redefine a name from an outer scope even if that name
has already been used in the inner scope. However, in a class, if a member uses a
name from an outer scope and that name is a type, then the class may not
subsequently redefine that name:
Click here to view code image
typedef double Money;
class Account {
Money balance() { return bal; }  // uses Money from the outer
C++ Primer, Fifth Edition
typedef double Money; // error: cannot redefine Money
Money bal;
// ...
It is worth noting that even though the definition of Money inside Account uses the
same type as the definition in the outer scope, this code is still in error.
Although it is an error to redefine a type name, compilers are not required to
diagnose this error. Some compilers will quietly accept such code, even though the
program is in error.
Definitions of type names usually should appear at the beginning of a class.
That way any member that uses that type will be seen after the type name
has already been defined.
Normal Block-Scope Name Lookup inside Member Definitions
A name used in the body of a member function is resolved as follows:
• First, look for a declaration of the name inside the member function. As usual,
only declarations in the function body that precede the use of the name are
• If the declaration is not found inside the member function, look for a declaration
inside the class. All the members of the class are considered.
• If a declaration for the name is not found in the class, look for a declaration
that is in scope before the member function definition.
Ordinarily, it is a bad idea to use the name of another member as the name for a
parameter in a member function. However, in order to show how names are resolved,
we’ll violate that normal practice in our dummy_fcn function:
Click here to view code image
// note: this code is for illustration purposes only and reflects bad practice
// it is generally a bad idea to use the same name for a parameter and a member
int height;   // defines a name subsequently used inside Screen
class Screen {
typedef std::string::size_type pos;
void dummy_fcn(pos height) {
cursor = width * height; // which height? the parameter
Documents you may be interested
Documents you may be interested